@reldens/cms 0.15.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()
@@ -55,7 +57,9 @@ class Frontend
         }
         this.templateEngine = new TemplateEngine({
             renderEngine: this.renderEngine,
-            dataServer: this.dataServer
+            dataServer: this.dataServer,
+            getPartials: this.getPartialsForDomain.bind(this),
+            entitiesConfig: this.entitiesConfig
         });
         await this.loadPartials();
         await this.setupDomainTemplates();
@@ -69,9 +73,9 @@ class Frontend
 
     async loadEntityAccessRules()
     {
-        let accessEntity = this.dataServer.getEntity('cmsEntityAccess');
+        let accessEntity = this.dataServer.getEntity('entitiesAccess');
         if(!accessEntity){
-            Logger.warning('CMS Entity Access not found.');
+            Logger.warning('Entities Access not found.');
             return;
         }
         let accessRules = await accessEntity.loadAll();
@@ -250,17 +254,24 @@ class Frontend
         try {
             let path = req.path;
             let domain = this.getDomainFromRequest(req);
-            let route = await this.findRouteByPath(path);
+            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) {
@@ -269,21 +280,31 @@ class Frontend
         }
     }
 
-    async findRouteByPath(path)
+    async findRouteByPath(path, domain)
     {
         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 route = await routesEntity.loadOneBy('path', path);
-        if(route){
-            return route;
+        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 === domainFilter){
+                matchingRoute = route;
+                break;
+            }
+            if(!route.domain){
+                nullDomain = route;
+            }
         }
-        if('/' === path){
-            return await routesEntity.loadOneBy('path', '/home');
+        if(matchingRoute){
+            return matchingRoute;
         }
-        return false;
+        return nullDomain;
     }
 
     async isEntityAccessible(entityName)
@@ -329,47 +350,163 @@ 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.content_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.content_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, {currentYear: new Date().getFullYear()}),
-            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, {currentYear: new Date().getFullYear()}),
-            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)
         );
     }
 
     async renderTemplate(templatePath, domain, res)
     {
-        let data = { currentYear: new Date().getFullYear() };
-        let content = await this.renderContentWithTemplate(templatePath, data, domain);
+        let content = await this.renderContentWithTemplate(templatePath, {}, domain);
         if(!content){
             return res.status(500).send('Template error: '+templatePath);
         }
-        return await this.renderWithLayout({content}, data, 'default', domain, res);
+        return await this.renderWithLayout({content}, {}, 'default', domain, res);
     }
 
     async renderContentWithTemplate(templatePath, data, domain)
@@ -384,23 +521,7 @@ class Frontend
 
     async renderWithLayout(content, data, layoutName, domain, res)
     {
-        let layoutPath = this.findLayoutPath(layoutName, domain);
-        let layoutContent = '';
-        if(layoutPath){
-            let layoutTemplate = FileHandler.readFile(layoutPath);
-            if(layoutTemplate){
-                layoutContent = await this.templateEngine.render(
-                    layoutTemplate,
-                    Object.assign({}, data, {
-                        content: sc.get(content, 'content', '')
-                    }),
-                    this.getPartialsForDomain(domain)
-                );
-            }
-        }
-        if('' === layoutContent){
-            layoutContent = sc.get(content, 'content', '');
-        }
+        let layoutContent = await this.processContentWithLayout(content, data, layoutName, domain);
         let pagePath = this.findTemplatePath('page', domain);
         if(!pagePath){
             return res.send(layoutContent);
@@ -412,28 +533,50 @@ class Frontend
         return res.send(
             await this.templateEngine.render(
                 pageTemplate,
-                Object.assign({}, data, {
-                    content: layoutContent,
-                    siteHandle: this.resolveDomainToSiteKey(domain)
-                }),
+                Object.assign({}, data, {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
                 this.getPartialsForDomain(domain)
             )
         );
     }
 
-    async renderNotFound(domain, res)
+    async processContentWithLayout(content, data, layoutName, domain)
     {
-        let templatePath = this.findTemplatePath('404', domain);
-        if(!templatePath){
-            return res.status(404).send('Page not found');
+        let processedContent = await this.processContent(content, data, domain);
+        let layoutPath = this.findLayoutPath(layoutName, domain);
+        if(!layoutPath){
+            return processedContent;
         }
-        let data = {title: '404 - Page Not Found', currentYear: new Date().getFullYear()};
-        let content = await this.renderContentWithTemplate(templatePath, data, domain);
-        if(!content){
-            return res.status(404).send('Page not found');
+        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 '';
+        }
+        return await this.templateEngine.render(contentText, data, this.getPartialsForDomain(domain));
+    }
+
+    async renderNotFound(domain, res)
+    {
+        let notFoundPath = this.findTemplatePath('404', domain);
+        if(notFoundPath){
+            let content = await this.renderContentWithTemplate(notFoundPath, {}, domain);
+            if(content){
+                res.status(404);
+                return await this.renderWithLayout({content}, {}, 'default', domain, res);
+            }
         }
-        res.status(404);
-        return await this.renderWithLayout({content}, data, 'default', domain, res);
+        return res.status(404).send('Page not found');
     }
 
 }

package/lib/installer.js

@@ -35,6 +35,7 @@ class Installer
         this.moduleAdminTemplatesPath = FileHandler.joinPaths(this.moduleAdminPath, 'templates')
         this.indexTemplatePath = FileHandler.joinPaths(this.defaultTemplatesPath, 'index.js.dist');
         this.postInstallCallback = sc.get(props, 'postInstallCallback', false);
+        this.prismaClient = sc.get(props, 'prismaClient', false);
         this.entitiesLoader = new EntitiesLoader({projectRoot: this.projectRoot});
     }
 
@@ -49,17 +50,21 @@ class Installer
             Logger.error('Missing app on prepareSetup for Installer.');
             return false;
         }
+        if(!appServer){
+            Logger.error('Missing appServer on prepareSetup for Installer.');
+            return false;
+        }
         if(!appServerFactory){
             Logger.error('Missing appServerFactory on prepareSetup for Installer.');
             return false;
         }
         if(!renderEngine){
-            Logger.error('Missing renderEngine for Installer.');
+            Logger.error('Missing renderEngine on prepareSetup for Installer.');
             return false;
         }
         this.app = app;
-        this.appServerFactory = appServerFactory;
         this.appServer = appServer;
+        this.appServerFactory = appServerFactory;
         this.renderEngine = renderEngine;
         app.use('/install-assets', appServerFactory.applicationFramework.static(this.installerPath, {index: false}));
         app.use(appServerFactory.session({
@@ -117,7 +122,7 @@ class Installer
             'configuration-error': 'Configuration error while completing installation.',
             'already-installed': 'The application is already installed.'
         };
-        return errorMessages[errorCode] || 'An unknown error occurred during installation.';
+        return sc.get(errorMessages, errorCode, 'An unknown error occurred during installation.');
     }
 
     async executeInstallProcess(req, res)
@@ -145,13 +150,8 @@ class Installer
             },
             debug: false
         };
-        if('prisma' === selectedDriver){
-            let generatedPrismaSchema = await this.generatePrismaSchema(dbConfig);
-            if(!generatedPrismaSchema){
-                Logger.error('Could not generated Prisma schema.');
-                return res.redirect('/?error=prisma-schema-generation-error');
-            }
-            Logger.info('Generated Prisma schema.');
+        if('prisma' === selectedDriver && this.prismaClient){
+            dbConfig.prismaClient = this.prismaClient;
         }
         let dbDriver = new driverClass(dbConfig);
         if(!await dbDriver.connect()){
@@ -181,7 +181,7 @@ class Installer
                 return res.redirect(redirectError);
             }
         }
-        let entitiesGenerationResult = await this.generateEntities(dbDriver);
+        let entitiesGenerationResult = await this.generateEntities(dbDriver, false, true);
         if(!entitiesGenerationResult){
             Logger.error('Entities generation error.');
             return res.redirect('/?error=installation-entities-generation-failed');
@@ -214,7 +214,7 @@ class Installer
             if(successFileContent){
                 successContent = this.renderEngine.render(
                     successFileContent,
-                    {adminPath: templateVariables['app-admin-path'], currentYear: new Date().getFullYear()},
+                    {adminPath: templateVariables['app-admin-path']},
                 );
             }
             return res.send(successContent);
@@ -234,7 +234,8 @@ class Installer
             Logger.error('SQL file "'+fileName+'" not found.');
             return '/?error=sql-file-not-found&file-name='+fileName;
         }
-        if(!await dbDriver.rawQuery(sqlFileContent)){
+        let queryExecutionResult = await dbDriver.rawQuery(sqlFileContent);
+        if(!queryExecutionResult){
             Logger.error('SQL file "'+fileName+'" raw execution failed.');
             return '/?error=sql-file-execution-error&file-name='+fileName;
         }
@@ -242,23 +243,35 @@ class Installer
         return '';
     }
 
-    async generateEntities(server, isOverride = 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){
+        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);
             if(dbConfig){
                 let generatedPrismaSchema = await this.generatePrismaSchema(dbConfig);
                 if(!generatedPrismaSchema){
-                    Logger.error('Could not generate Prisma schema for entities generation.');
+                    Logger.error('Prisma schema generation failed.');
                     return false;
                 }
                 Logger.info('Generated Prisma schema for entities generation.');
             }
         }
-        let generator = new EntitiesGenerator({server, projectPath: this.projectRoot, isOverride});
+        if('prisma' === driverType && isDryPrisma){
+            Logger.info('Skipping Prisma schema generation due to --dry-prisma flag.');
+        }
+        let generatorConfig = {
+            server,
+            projectPath: this.projectRoot,
+            isOverride
+        };
+        if('prisma' === driverType && this.prismaClient){
+            generatorConfig.prismaClient = this.prismaClient;
+        }
+        let generator = new EntitiesGenerator(generatorConfig);
         let success = await generator.generate();
         if(!success){
             Logger.error('Entities generation failed.');
@@ -303,7 +316,8 @@ class Installer
         let generator = new PrismaSchemaGenerator({
             ...connectionData,
             dataProxy: useDataProxy,
-            prismaSchemaPath: this.projectRoot+'/prisma'
+            clientOutputPath: FileHandler.joinPaths(this.projectRoot, 'prisma', 'client'),
+            prismaSchemaPath: FileHandler.joinPaths(this.projectRoot, 'prisma')
         });
         let success = await generator.generate();
         if(!success){
@@ -363,12 +377,22 @@ class Installer
     async createIndexJsFile(templateVariables)
     {
         if(!FileHandler.exists(this.indexTemplatePath)){
-            Logger.error('Index.js template not found: '+this.indexTemplatePath);
+            Logger.error('Index.js template not found: ' + this.indexTemplatePath);
             return false;
         }
         let indexTemplate = FileHandler.readFile(this.indexTemplatePath);
         let driverKey = templateVariables['db-storage-driver'];
-        let indexContent = this.renderEngine.render(indexTemplate, {driverKey});
+        let templateParams = {driverKey};
+        if('prisma' === driverKey){
+            let prismaClientPath = FileHandler.joinPaths(this.projectRoot, 'prisma', 'client');
+            templateParams.prismaClientImports = 'const { PrismaClient } = require(\'' + prismaClientPath + '\');';
+            templateParams.prismaClientParam = ',\n    prismaClient: new PrismaClient()';
+        }
+        if('prisma' !== driverKey){
+            templateParams.prismaClientImports = '';
+            templateParams.prismaClientParam = '';
+        }
+        let indexContent = this.renderEngine.render(indexTemplate, templateParams);
         let indexFilePath = FileHandler.joinPaths(this.projectRoot, 'index.js');
         if(FileHandler.exists(indexFilePath)){
             Logger.info('Index.js file already exists, the CMS installer will not override the existent one.');

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;