@reldens/cms 0.15.0 → 0.16.0

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,32 @@ class Installer
         return '';
     }
 
-    async generateEntities(server, isOverride = false)
+    async generateEntities(server, isOverride = false, isInstallationMode = 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){
+            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});
+        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 +313,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 +374,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/manager.js

@@ -14,6 +14,7 @@ const { TemplatesToPathMapper } = require('./templates-to-path-mapper');
 const { AdminEntitiesGenerator } = require('./admin-entities-generator');
 const { LoadedEntitiesProcessor } = require('./loaded-entities-processor');
 const { AdminManager } = require('./admin-manager');
+const { CmsPagesRouteManager } = require('./cms-pages-route-manager');
 const { Installer } = require('./installer');
 const { Frontend } = require('./frontend');
 const { EventsManagerSingleton, Logger, sc } = require('@reldens/utils');
@@ -47,6 +48,7 @@ class Manager
         this.mimeTypes = sc.get(props, 'mimeTypes', MimeTypes);
         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');
         this.scriptsFilePath = sc.get(props, 'scriptsFilePath', '/js/reldens-admin-client.js');
         this.companyName = sc.get(props, 'companyName', 'Reldens - CMS');
@@ -62,16 +64,22 @@ class Manager
         this.adminManager = sc.get(props, 'adminManager', false);
         this.frontend = sc.get(props, 'frontend', false);
         this.renderEngine = sc.get(props, 'renderEngine', mustache);
+        this.prismaClient = sc.get(props, 'prismaClient', false);
         this.appServerFactory = new AppServerFactory();
         this.adminEntitiesGenerator = new AdminEntitiesGenerator();
         this.installer = new Installer({
             projectRoot: this.projectRoot,
+            prismaClient: this.prismaClient,
             postInstallCallback: this.initializeCmsAfterInstall.bind(this)
         });
         this.useProvidedServer = this.validateProvidedServer();
         this.useProvidedDataServer = this.validateProvidedDataServer();
         this.useProvidedAdminManager = this.validateProvidedAdminManager();
         this.useProvidedFrontend = this.validateProvidedFrontend();
+        this.cmsPagesRouteManager = new CmsPagesRouteManager({
+            dataServer: this.dataServer,
+            events: this.events
+        });
     }
 
     validateProvidedServer()
@@ -206,8 +214,10 @@ class Manager
 
     async initializeServices()
     {
+        this.events.emit('reldens.cmsManagerInitializeServices', {manager: this});
         if(!this.useProvidedDataServer){
             if(!await this.initializeDataServer()){
+                Logger.debug('Initialize Data Server failed.');
                 return false;
             }
         }
@@ -215,32 +225,41 @@ class Manager
             await this.setupEntityAccess();
         }
         if(!this.loadProcessedEntities()){
+            Logger.debug('Load Processed Entities for Entities failed.');
             return false;
         }
         if(!await this.generateAdminEntities()){
+            Logger.debug('Generate Admin Entities for Entities failed.');
             return false;
         }
         if(!this.useProvidedAdminManager){
             if(!await this.initializeAdminManager()){
+                Logger.debug('Initialize Admin Manager failed.');
                 return false;
             }
         }
+        if(!await this.initializeCmsPagesRouteManager()){
+            Logger.debug('Initialize CMS Pages Route Manager failed.');
+            return false;
+        }
         if(!this.useProvidedFrontend){
             if(!await this.initializeFrontend()){
+                Logger.debug('Initialize Frontend failed.');
                 return false;
             }
         }
         if(!this.useProvidedServer){
             await this.appServer.listen(this.config.port);
         }
+        Logger.debug('Initialize Services successfully.');
         return true;
     }
 
     async setupEntityAccess()
     {
-        let accessEntity = this.dataServer.getEntity('cmsEntityAccess');
+        let accessEntity = this.dataServer.getEntity('entitiesAccess');
         if(!accessEntity){
-            Logger.warning('Entity access control table not found.');
+            Logger.warning('Entities Access not found.');
             return;
         }
         for(let entityName of Object.keys(this.entityAccess)){
@@ -305,12 +324,15 @@ class Manager
             },
             rawEntities: this.rawRegisteredEntities
         };
-        let DriverClass = DriversMap[this.config.database.driver];
-        if(!DriverClass){
+        let driverClass = DriversMap[this.config.database.driver];
+        if(!driverClass){
             Logger.critical('Invalid database driver: '+this.config.database.driver);
             return false;
         }
-        this.dataServer = new DriverClass(dbConfig);
+        if('prisma' === this.config.database.driver && this.prismaClient){
+            dbConfig.prismaClient = this.prismaClient;
+        }
+        this.dataServer = new driverClass(dbConfig);
         if(!await this.dataServer.connect()){
             Logger.critical('Failed to connect to database.');
             return false;
@@ -347,6 +369,14 @@ class Manager
                 return passwordResult;
             };
         }
+        let adminFilesContents = await AdminTemplatesLoader.fetchAdminFilesContents(this.mappedAdminTemplates);
+        let translations = AdminTranslations.appendTranslations(this.entitiesTranslations || {});
+        this.events.emit('reldens.manager.initializeAdminManager', {
+            manager: this,
+            authenticationCallback,
+            adminFilesContents,
+            translations
+        });
         let adminConfig = {
             events: this.events,
             dataServer: this.dataServer,
@@ -358,10 +388,8 @@ class Manager
             renderCallback: this.renderCallback.bind(this),
             secret: this.config.adminSecret,
             rootPath: this.config.adminPath,
-            translations: AdminTranslations.appendTranslations(this.entitiesTranslations || {}),
-            adminFilesContents: await AdminTemplatesLoader.fetchAdminFilesContents(
-                TemplatesToPathMapper.map(this.adminTemplatesList, this.projectAdminTemplatesPath)
-            ),
+            translations: translations,
+            adminFilesContents,
             mimeTypes: this.mimeTypes,
             allowedExtensions: this.allowedExtensions,
             adminRoleId: this.adminRoleId,
@@ -381,6 +409,17 @@ class Manager
         return true;
     }
 
+    async initializeCmsPagesRouteManager()
+    {
+        if(!this.dataServer){
+            Logger.warning('CmsPagesRouteManager initialization skipped - missing dataServer.');
+            return false;
+        }
+        this.cmsPagesRouteManager.dataServer = this.dataServer;
+        Logger.debug('CmsPagesRouteManager initialized successfully');
+        return true;
+    }
+
     async renderCallback(template, params = {})
     {
         if(!template){