@reldens/cms 0.6.0 → 0.8.0

package/lib/frontend.js

@@ -19,7 +19,6 @@ class Frontend
         this.projectRoot = sc.get(props, 'projectRoot', './');
         this.templatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
         this.publicPath = FileHandler.joinPaths(this.projectRoot, 'public');
-        this.encoding = sc.get(props, 'encoding', 'utf8');
         this.error = false;
     }
 
@@ -65,12 +64,14 @@ class Frontend
         try {
             let route = await this.findRouteByPath(path);
             if(route){
+                Logger.debug('Found route for path: '+path, route);
                 return await this.renderContentFromRoute(res, route);
             }
             let pathSegments = path.split('/').filter(segment => segment !== '');
             if(0 < pathSegments.length){
                 let entityResult = await this.findEntityByPath(pathSegments);
                 if(entityResult){
+                    Logger.debug('Found entity for path segments: '+pathSegments.join('/'));
                     return await this.renderContentFromEntity(
                         res,
                         entityResult.entity,
@@ -80,8 +81,10 @@ class Frontend
             }
             let templatePath = this.findTemplateByPath(path);
             if(templatePath){
+                Logger.debug('Found template for path: '+path+' at: '+templatePath);
                 return await this.renderTemplateOnly(res, templatePath);
             }
+            Logger.debug('No template found for path: '+path+', rendering 404');
             return await this.renderNotFoundPage(res);
         } catch (error) {
             Logger.error('Request handling error: '+error.message);
@@ -91,32 +94,41 @@ class Frontend
 
     async findRouteByPath(path)
     {
-        if('/' === path){
-            path = '/home';
-        }
         let routesEntity = this.dataServer.getEntity('routes');
         if(!routesEntity){
+            Logger.error('Routes entity not found in dataServer');
             return false;
         }
-        return await routesEntity.loadOneBy('path', path);
+        let route = await routesEntity.loadOneBy('path', path);
+        if(route){
+            return route;
+        }
+        if('/' === path){
+            return await routesEntity.loadOneBy('path', '/home');
+        }
+        return false;
     }
 
     async findEntityByPath(pathSegments)
     {
         if(1 > pathSegments.length){
+            Logger.debug('No path segments provided');
             return false;
         }
         let entityName = pathSegments[0];
         let entityId = 2 > pathSegments.length ? false : pathSegments[1];
         if(!entityId){
+            Logger.debug('No entity ID in path segments');
             return false;
         }
         let entity = this.dataServer.getEntity(entityName);
         if(!entity){
+            Logger.debug('Entity not found: '+entityName);
             return false;
         }
         let loadedEntity = await entity.loadById(entityId);
         if(!loadedEntity){
+            Logger.debug('Entity not loaded by ID: '+entityId);
             return false;
         }
         return {
@@ -146,14 +158,17 @@ class Frontend
     async renderContentFromRoute(res, route)
     {
         if(!route.router || !route.content_id){
+            Logger.debug('Route missing router or content_id');
             return await this.renderNotFoundPage(res);
         }
         let entity = this.dataServer.getEntity(route.router);
         if(!entity){
+            Logger.debug('Entity not found: '+route.router);
             return await this.renderNotFoundPage(res);
         }
         let content = await entity.loadById(route.content_id);
         if(!content){
+            Logger.debug('Content not found for ID: '+route.content_id+' in entity: '+route.router);
             return await this.renderNotFoundPage(res);
         }
         let templateName = content.template || route.router;
@@ -161,12 +176,11 @@ class Frontend
         if(!FileHandler.exists(templatePath)){
             templatePath = FileHandler.joinPaths(this.templatesPath, 'page.html');
             if(!FileHandler.exists(templatePath)){
+                Logger.debug('Neither template found: '+templateName+'.html nor page.html');
                 return await this.renderNotFoundPage(res);
             }
         }
-        let template = FileHandler.readFile(templatePath, {
-            encoding: this.encoding
-        }).toString();
+        let template = FileHandler.readFile(templatePath).toString();
         let data = {
             ...route,
             ...content,
@@ -185,9 +199,7 @@ class Frontend
                 return await this.renderNotFoundPage(res);
             }
         }
-        let template = FileHandler.readFile(templatePath, {
-            encoding: this.encoding
-        }).toString();
+        let template = FileHandler.readFile(templatePath).toString();
         let data = {
             ...entity,
             title: entity.title || entity.name || entityName,
@@ -199,9 +211,7 @@ class Frontend
 
     async renderTemplateOnly(res, templatePath)
     {
-        let template = FileHandler.readFile(templatePath, {
-            encoding: this.encoding
-        }).toString();
+        let template = FileHandler.readFile(templatePath).toString();
         let data = {
             title: 'Page Title',
             current_year: new Date().getFullYear()
@@ -216,9 +226,7 @@ class Frontend
         if(!FileHandler.exists(templatePath)){
             return res.status(404).send('Page not found');
         }
-        let template = FileHandler.readFile(templatePath, {
-            encoding: this.encoding
-        }).toString();
+        let template = FileHandler.readFile(templatePath).toString();
         let data = {
             title: '404 - Page Not Found',
             current_year: new Date().getFullYear()

package/lib/installer.js

@@ -7,7 +7,6 @@
 const { FileHandler, Encryptor } = require('@reldens/server-utils');
 const { DriversMap, EntitiesGenerator, PrismaSchemaGenerator } = require('@reldens/storage');
 const { EntitiesLoader } = require('./entities-loader');
-const { AdminEntitiesGenerator } = require('./admin-entities-generator');
 const { Logger, sc } = require('@reldens/utils');
 const mustache = require('mustache');
 
@@ -20,7 +19,11 @@ class Installer
         this.appServer = sc.get(props, 'appServer', false);
         this.appServerFactory = sc.get(props, 'appServerFactory', false);
         this.projectRoot = sc.get(props, 'projectRoot', './');
-        this.encoding = sc.get(props, 'encoding', 'utf8');
+        this.projectTemplatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
+        this.projectPublicPath = FileHandler.joinPaths(this.projectRoot, 'public');
+        this.projectPublicAssetsPath = FileHandler.joinPaths(this.projectPublicPath, 'assets');
+        this.projectCssPath = FileHandler.joinPaths(this.projectPublicPath, 'css');
+        this.projectJsPath = FileHandler.joinPaths(this.projectPublicPath, 'js');
         this.installLockPath = FileHandler.joinPaths(this.projectRoot, 'install.lock');
         this.envFilePath = FileHandler.joinPaths(this.projectRoot, '.env');
         this.modulePath = FileHandler.joinPaths(__dirname, '..');
@@ -28,10 +31,11 @@ class Installer
         this.migrationsPath = FileHandler.joinPaths(this.modulePath, 'migrations');
         this.defaultTemplatesPath = FileHandler.joinPaths(this.modulePath, 'templates');
         this.moduleAdminPath = FileHandler.joinPaths(this.modulePath, 'admin');
+        this.moduleAdminAssetsPath = FileHandler.joinPaths(this.moduleAdminPath, 'assets');
+        this.moduleAdminTemplatesPath = FileHandler.joinPaths(this.moduleAdminPath, 'templates')
         this.indexTemplatePath = FileHandler.joinPaths(this.defaultTemplatesPath, 'index.js.dist');
         this.postInstallCallback = sc.get(props, 'postInstallCallback', false);
         this.entitiesLoader = new EntitiesLoader({projectRoot: this.projectRoot});
-        this.adminEntitiesGenerator = new AdminEntitiesGenerator();
     }
 
     isInstalled()
@@ -99,10 +103,11 @@ class Installer
             'connection-failed': 'Database connection failed. Please check your credentials.',
             'raw-query-not-found': 'Query method not found in driver.',
             'sql-file-not-found': 'SQL installation file not found.',
-            'sql-tables-creation-failed': 'Failed to create database tables.',
+            'sql-cms-tables-creation-failed': 'Failed to create CMS tables.',
+            'sql-user-auth-creation-failed': 'Failed to create user authentication tables.',
             'sql-default-user-error': 'Failed to create default user.',
+            'sql-default-homepage-error': 'Failed to create default homepage.',
             'installation-entities-generation-failed': 'Failed to generate entities.',
-            'installation-process-failed': 'Installation process failed.',
             'installation-entities-callback-failed': 'Failed to process entities for callback.',
             'configuration-error': 'Configuration error while completing installation.',
             'already-installed': 'The application is already installed.'
@@ -136,7 +141,11 @@ class Installer
             debug: false
         };
         if('prisma' === selectedDriver){
-            await this.generatePrismaSchema(dbConfig);
+            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.');
         }
         let dbDriver = new driverClass(dbConfig);
@@ -148,67 +157,44 @@ class Installer
             Logger.error('Method "rawQuery" not found.');
             return res.redirect('/?error=raw-query-not-found');
         }
-        let installSqlPath = FileHandler.joinPaths(this.migrationsPath, 'install.sql');
-        if(!FileHandler.exists(installSqlPath)){
-            Logger.error('SQL installation file not found.');
-            return res.redirect('/?error=sql-file-not-found');
-        }
-        let queryTablesResult = await this.executeQueryFile(dbDriver, installSqlPath);
-        if(!queryTablesResult){
-            Logger.error('Tables creation failed.');
-            return res.redirect('/?error=sql-tables-creation-failed');
-        }
-        Logger.info('Installed tables.');
-        let defaultUserSqlPath = FileHandler.joinPaths(this.migrationsPath, 'default-user.sql');
-        try {
-            if(FileHandler.exists(defaultUserSqlPath)){
-                let queryUserResult = await this.executeQueryFile(dbDriver, defaultUserSqlPath);
-                if(!queryUserResult){
-                    Logger.error('Default user creation failed.', queryUserResult);
-                    return res.redirect('/?error=sql-default-user-error');
-                }
-                Logger.info('Created default user.');
-            }
-            let entitiesGenerationResult = await this.generateEntities(dbDriver);
-            if(!entitiesGenerationResult){
-                Logger.error('Entities generation error.');
-                return res.redirect('/?error=installation-entities-generation-failed');
+        let executeFiles = {
+            'install-cms-tables': 'install.sql',
+            'install-user-auth': 'users-authentication.sql',
+            'install-default-user': 'default-user.sql',
+            'install-default-homepage': 'default-homepage.sql'
+        };
+        for(let checkboxName of Object.keys(executeFiles)){
+            let fileName = executeFiles[checkboxName];
+            let redirectError = await this.executeQueryFile(
+                sc.get(templateVariables, checkboxName, 'off'),
+                fileName,
+                dbDriver
+            );
+            if('' !== redirectError){
+                return res.redirect(redirectError);
             }
-            Logger.info('Generated entities.');
-        } catch (error) {
-            Logger.error('Installation error: '+error.message);
-            return res.redirect('/?error=installation-process-failed');
         }
+        let entitiesGenerationResult = await this.generateEntities(dbDriver);
+        if(!entitiesGenerationResult){
+            Logger.error('Entities generation error.');
+            return res.redirect('/?error=installation-entities-generation-failed');
+        }
+        Logger.info('Generated entities.');
         try {
-            await this.createEnvFile(templateVariables);
+            let mappedVariablesForConfig = this.mapVariablesForConfig(templateVariables);
+            await this.createEnvFile(this.mapVariablesForTemplate(mappedVariablesForConfig));
             await this.prepareProjectDirectories();
             await this.copyAdminDirectory();
             await this.createIndexJsFile(templateVariables);
             if(sc.isFunction(this.postInstallCallback)){
-                let loadedEntities = this.entitiesLoader.loadEntities(selectedDriver);
-                if(loadedEntities.rawRegisteredEntities){
-                    dbDriver.rawEntities = {};
-                    let entityNames = Object.keys(loadedEntities.rawRegisteredEntities);
-                    for(let i = 0; i < entityNames.length; i++){
-                        let entityName = entityNames[i];
-                        dbDriver.rawEntities[entityName] = loadedEntities.rawRegisteredEntities[entityName];
-                    }
-                    await dbDriver.generateEntities();
-                    let adminEntities = this.adminEntitiesGenerator.generate(
-                        loadedEntities.rawRegisteredEntities,
-                        dbDriver.entityManager.entities
-                    );
-                    if(this.appServer && sc.isFunction(this.appServer.close)){
-                        await this.appServer.close();
-                    }
-                    Logger.debug('Running postInstallCallback.');
-                    await this.postInstallCallback({
-                        entities: adminEntities,
-                        rawEntities: loadedEntities.rawRegisteredEntities,
-                        entitiesConfig: loadedEntities.entitiesConfig || {},
-                        entitiesTranslations: loadedEntities.entitiesTranslations || {}
-                    });
+                if(this.appServer && sc.isFunction(this.appServer.close)){
+                    await this.appServer.close();
                 }
+                Logger.debug('Running postInstallCallback.');
+                await this.postInstallCallback({
+                    loadedEntities: this.entitiesLoader.loadEntities(selectedDriver),
+                    mappedVariablesForConfig
+                });
             }
             await this.createLockFile();
             Logger.info('Installation successful!');
@@ -219,18 +205,28 @@ class Installer
             }
             return res.send(successContent);
         } catch (error) {
-            Logger.error('Configuration error: '+error.message);
-            return res.redirect('/?error=configuration-error');
+            Logger.critical('Configuration error: '+error.message);
+            return res.redirect('/?error=installation-error');
         }
     }
 
-    async executeQueryFile(dbDriver, filePath)
+    async executeQueryFile(isMarked, fileName, dbDriver)
     {
-        let sqlContent = FileHandler.readFile(filePath);
-        if(!sqlContent){
-            throw new Error('Could not read SQL file: '+filePath);
+        if('on' !== isMarked){
+            return '';
         }
-        return await dbDriver.rawQuery(sqlContent.toString());
+        let sqlFileContent = FileHandler.readFile(FileHandler.joinPaths(this.migrationsPath, fileName));
+        if(!sqlFileContent){
+            Logger.error('SQL file "'+fileName+'" not found.');
+            return '/?error=sql-file-not-found&file-name='+fileName;
+        }
+        let queryResult = await dbDriver.rawQuery(sqlFileContent.toString());
+        if(!queryResult){
+            Logger.error('SQL file "'+fileName+'" raw execution failed.');
+            return '/?error=sql-file-execution-error&file-name='+fileName;
+        }
+        Logger.info('SQL file "'+fileName+'" raw execution successfully.');
+        return '';
     }
 
     async generateEntities(server)
@@ -262,25 +258,48 @@ class Installer
     async createEnvFile(templateVariables)
     {
         let envTemplatePath = FileHandler.joinPaths(this.defaultTemplatesPath, '.env.dist');
-        if(!FileHandler.exists(envTemplatePath)){
-            Logger.error('ENV template not found: '+envTemplatePath);
+        let envTemplateContent = FileHandler.readFile(envTemplatePath);
+        if(!envTemplateContent){
+            Logger.error('Template ".env.dist" not found: '+envTemplatePath);
             return false;
         }
-        let envTemplate = FileHandler.readFile(envTemplatePath);
-        let envContent = mustache.render(envTemplate, {
-            dbClient: templateVariables['db-client'],
-            dbHost: templateVariables['db-host'],
-            dbPort: templateVariables['db-port'],
-            dbName: templateVariables['db-name'],
-            dbUser: templateVariables['db-username'],
-            dbPassword: templateVariables['db-password'],
-            dbDriver: templateVariables['db-storage-driver'],
-            adminPath: templateVariables['app-admin-path'],
-            adminSecret: Encryptor.generateSecretKey(),
-            host: templateVariables['app-host'],
-            port: templateVariables['app-port']
-        });
-        return FileHandler.writeFile(this.envFilePath, envContent);
+        return FileHandler.writeFile(this.envFilePath, mustache.render(envTemplateContent, templateVariables));
+    }
+
+    mapVariablesForTemplate(configVariables)
+    {
+        return {
+            host: configVariables.host,
+            port: configVariables.port,
+            adminPath: configVariables.adminPath,
+            adminSecret: configVariables.adminSecret,
+            dbClient: configVariables.database.client,
+            dbHost: configVariables.database.host,
+            dbPort: configVariables.database.port,
+            dbName: configVariables.database.name,
+            dbUser: configVariables.database.user,
+            dbPassword: configVariables.database.password,
+            dbDriver: configVariables.database.driver
+        };
+    }
+
+    mapVariablesForConfig(templateVariables)
+    {
+        return {
+            host: sc.get(templateVariables, 'app-host', 'http://localhost'),
+            port: Number(sc.get(templateVariables, 'app-port', 8080)),
+            adminPath: sc.get(templateVariables, 'app-admin-path', '/reldens-admin'),
+            adminSecret: sc.get(templateVariables, 'app-admin-secret', Encryptor.generateSecretKey()),
+            database: {
+                client: sc.get(templateVariables, 'db-client', 'mysql'),
+                host: sc.get(templateVariables, 'db-host', 'localhost'),
+                port: Number(sc.get(templateVariables, 'db-port', 3306)),
+                name: sc.get(templateVariables, 'db-name', 'reldens_cms'),
+                user: sc.get(templateVariables, 'db-username', ''),
+                password: sc.get(templateVariables, 'db-password', ''),
+                driver: sc.get(templateVariables, 'db-storage-driver', 'prisma')
+            }
+        };
     }
 
     async createIndexJsFile(templateVariables)
@@ -316,40 +335,49 @@ class Installer
             Logger.error('Admin folder not found in module path: '+this.moduleAdminPath);
             return false;
         }
-        FileHandler.copyFolderSync(this.moduleAdminPath, projectAdminPath);
+        let projectAdminTemplates = FileHandler.joinPaths(projectAdminPath, 'templates');
+        FileHandler.copyFolderSync(this.moduleAdminTemplatesPath, projectAdminTemplates);
+        FileHandler.copyFolderSync(this.moduleAdminAssetsPath, this.projectPublicAssetsPath);
+        FileHandler.copyFile(
+            FileHandler.joinPaths(this.moduleAdminPath, 'reldens-admin-client.css'),
+            FileHandler.joinPaths(this.projectCssPath, 'reldens-admin-client.css'),
+        );
+        FileHandler.copyFile(
+            FileHandler.joinPaths(this.moduleAdminPath, 'reldens-admin-client.js'),
+            FileHandler.joinPaths(this.projectJsPath, 'reldens-admin-client.js'),
+        );
         Logger.info('Admin folder copied to project root.');
         return true;
     }
 
     async prepareProjectDirectories()
     {
-        let projectTemplatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
-        FileHandler.createFolder(projectTemplatesPath);
-        let projectPublicPath = FileHandler.joinPaths(this.projectRoot, 'public');
-        FileHandler.createFolder(projectPublicPath);
-        let projectCssPath = FileHandler.joinPaths(projectPublicPath, 'css');
-        FileHandler.createFolder(projectCssPath);
-        let projectJsPath = FileHandler.joinPaths(projectPublicPath, 'js');
-        FileHandler.createFolder(projectJsPath);
-        FileHandler.copyFile(
-            FileHandler.joinPaths(this.defaultTemplatesPath, 'page.html'),
-            FileHandler.joinPaths(projectTemplatesPath, 'page.html')
-        );
-        FileHandler.copyFile(
-            FileHandler.joinPaths(this.defaultTemplatesPath, '404.html'),
-            FileHandler.joinPaths(projectTemplatesPath, '404.html')
-        );
-        FileHandler.copyFile(
-            FileHandler.joinPaths(this.defaultTemplatesPath, 'layout.html'),
-            FileHandler.joinPaths(projectTemplatesPath, 'layout.html')
-        );
+        FileHandler.createFolder(this.projectTemplatesPath);
+        FileHandler.createFolder(this.projectPublicPath);
+        FileHandler.createFolder(this.projectPublicAssetsPath);
+        FileHandler.createFolder(this.projectCssPath);
+        FileHandler.createFolder(this.projectJsPath);
+        let baseFiles = [
+            'page.html',
+            '404.html',
+            'layout.html',
+            'browserconfig.xml',
+            'favicon.ico',
+            'site.webmanifest'
+        ];
+        for(let fileName of baseFiles){
+            FileHandler.copyFile(
+                FileHandler.joinPaths(this.defaultTemplatesPath, fileName),
+                FileHandler.joinPaths(this.projectTemplatesPath, fileName)
+            );
+        }
         FileHandler.copyFile(
             FileHandler.joinPaths(this.defaultTemplatesPath, 'css', 'styles.css'),
-            FileHandler.joinPaths(projectCssPath, 'styles.css')
+            FileHandler.joinPaths(this.projectCssPath, 'styles.css')
         );
         FileHandler.copyFile(
             FileHandler.joinPaths(this.defaultTemplatesPath, 'js', 'scripts.js'),
-            FileHandler.joinPaths(projectJsPath, 'scripts.js')
+            FileHandler.joinPaths(this.projectJsPath, 'scripts.js')
         );
         return true;
     }
@@ -357,16 +385,16 @@ class Installer
     fetchDefaults()
     {
         return {
-            'app-host': process.env.RELDENS_CMS_HOST || 'http://localhost',
-            'app-port': process.env.RELDENS_CMS_PORT || '8000',
-            'app-admin-path': process.env.RELDENS_CMS_ADMIN_PATH || '/reldens-admin',
-            'db-storage-driver': 'prisma',
-            'db-client': process.env.RELDENS_CMS_DB_CLIENT || 'mysql',
-            'db-host': process.env.RELDENS_CMS_DB_HOST || 'localhost',
-            'db-port': process.env.RELDENS_CMS_DB_PORT || '3306',
-            'db-name': process.env.RELDENS_CMS_DB_NAME || 'reldens_cms',
-            'db-username': process.env.RELDENS_CMS_DB_USER || '',
-            'db-password': process.env.RELDENS_CMS_DB_PASSWORD || ''
+            'app-host': process.env.RELDENS_APP_HOST || 'http://localhost',
+            'app-port': process.env.RELDENS_APP_PORT || '8080',
+            'app-admin-path': process.env.RELDENS_ADMIN_ROUTE_PATH || '/reldens-admin',
+            'db-storage-driver': process.env.RELDENS_STORAGE_DRIVER || 'prisma',
+            'db-client': process.env.RELDENS_DB_CLIENT || 'mysql',
+            'db-host': process.env.RELDENS_DB_HOST || 'localhost',
+            'db-port': process.env.RELDENS_DB_PORT || '3306',
+            'db-name': process.env.RELDENS_DB_NAME || 'reldens_cms',
+            'db-username': process.env.RELDENS_DB_USER || '',
+            'db-password': process.env.RELDENS_DB_PASSWORD || ''
         };
     }
 }

package/lib/loaded-entities-processor.js

@@ -0,0 +1,30 @@
+/**
+ *
+ * Reldens - LoadedEntitiesProcessor
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class LoadedEntitiesProcessor
+{
+
+    process(rawRegisteredEntities, entitiesTranslations, entitiesConfig)
+    {
+        let exportedEntitiesList = Object.keys(rawRegisteredEntities);
+        if(0 === exportedEntitiesList.length){
+            return {};
+        }
+        let entities = {};
+        for (let i of exportedEntitiesList) {
+            entities[i] = {
+                rawEntity: rawRegisteredEntities[i],
+                config: sc.isFunction(entitiesConfig) ? entitiesConfig(props)[i] : entitiesConfig[i]
+            };
+        }
+        return {entities, entitiesRaw: rawRegisteredEntities, translations: entitiesTranslations};
+    }
+
+}
+
+module.exports.LoadedEntitiesProcessor = new LoadedEntitiesProcessor();