@reldens/cms 0.6.0 → 0.8.0

package/lib/manager.js

@@ -4,12 +4,21 @@
  *
  */
 
-const { AppServerFactory, FileHandler, Encryptor } = require('@reldens/server-utils');
-const { DriversMap } = require('@reldens/storage');
+const { TemplatesList } = require('./templates-list');
+const { AdminTranslations } = require('./admin-translations');
+const { AdminTemplatesLoader } = require('./admin-templates-loader');
+const { AdminManagerValidator } = require('./admin-manager-validator');
+const { MimeTypes } = require('./mime-types');
+const { AllowedExtensions } = require('./allowed-extensions');
+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 { Installer } = require('./installer');
 const { Frontend } = require('./frontend');
 const { EventsManagerSingleton, Logger, sc } = require('@reldens/utils');
+const { DriversMap } = require('@reldens/storage');
+const { AppServerFactory, FileHandler, Encryptor } = require('@reldens/server-utils');
 const dotenv = require('dotenv');
 const mustache = require('mustache');
 
@@ -23,41 +32,117 @@ class Manager
         this.installLockPath = FileHandler.joinPaths(this.projectRoot, 'install.lock');
         dotenv.config({path: this.envFilePath});
         this.config = this.loadConfigFromEnv();
-        this.entities = sc.get(props, 'entities', {});
-        this.rawEntities = sc.get(props, 'rawEntities', {});
-        this.entitiesConfig = sc.get(props, 'entitiesConfig', {});
+        this.adminEntities = sc.get(props, 'adminEntities', {});
+        this.rawRegisteredEntities = sc.get(props, 'rawRegisteredEntities', {});
         this.entitiesTranslations = sc.get(props, 'entitiesTranslations', {});
+        this.entitiesConfig = sc.get(props, 'entitiesConfig', {});
+        this.processedEntities = sc.get(props, 'processedEntities', {});
         this.authenticationMethod = sc.get(props, 'authenticationMethod', 'db-users');
         this.authenticationCallback = sc.get(props, 'authenticationCallback', false);
         this.events = sc.get(props, 'events', EventsManagerSingleton);
+        this.adminTemplatesList = sc.get(props, 'adminTemplatesList', TemplatesList);
+        this.projectAdminPath = FileHandler.joinPaths(this.projectRoot, 'admin');
+        this.projectAdminTemplatesPath = FileHandler.joinPaths(this.projectAdminPath, 'templates');
+        this.mimeTypes = sc.get(props, 'mimeTypes', MimeTypes);
+        this.allowedExtensions = sc.get(props, 'allowedExtensions', AllowedExtensions)
+        this.adminRoleId = sc.get(props, 'adminRoleId', 99);
+        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');
+        this.logo = sc.get(props, 'logo', '/assets/web/reldens-your-logo-mage.png');
+        this.favicon = sc.get(props, 'favicon', '/assets/web/favicon.ico');
+        this.app = sc.get(props, 'app', false);
+        this.appServer = sc.get(props, 'appServer', false);
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.adminManager = sc.get(props, 'adminManager', false);
+        this.frontend = sc.get(props, 'frontend', false);
         this.appServerFactory = new AppServerFactory();
+        this.adminEntitiesGenerator = new AdminEntitiesGenerator();
         this.installer = new Installer({
             projectRoot: this.projectRoot,
             postInstallCallback: this.initializeCmsAfterInstall.bind(this)
         });
-        this.dataServer = false;
-        this.app = false;
-        this.appServer = false;
-        this.adminManager = false;
-        this.frontend = false;
+        this.useProvidedServer = this.validateProvidedServer();
+        this.useProvidedDataServer = this.validateProvidedDataServer();
+        this.useProvidedAdminManager = this.validateProvidedAdminManager();
+        this.useProvidedFrontend = this.validateProvidedFrontend();
+    }
+
+    validateProvidedServer()
+    {
+        if(!this.app){
+            return false;
+        }
+        if(!this.appServer){
+            return false;
+        }
+        if('function' !== typeof this.app.use){
+            Logger.critical('Invalid app instance provided - missing use method.');
+            return false;
+        }
+        if('function' !== typeof this.appServer.listen){
+            Logger.critical('Invalid appServer instance provided - missing listen method.');
+            return false;
+        }
+        return true;
+    }
+
+    validateProvidedDataServer()
+    {
+        if(!this.dataServer){
+            return false;
+        }
+        if('function' !== typeof this.dataServer.connect){
+            Logger.critical('Invalid dataServer instance provided - missing connect method.');
+            return false;
+        }
+        if('function' !== typeof this.dataServer.generateEntities){
+            Logger.critical('Invalid dataServer instance provided - missing generateEntities method.');
+            return false;
+        }
+        return true;
+    }
+
+    validateProvidedAdminManager()
+    {
+        if(!this.adminManager){
+            return false;
+        }
+        if('function' !== typeof this.adminManager.setupAdmin){
+            Logger.critical('Invalid adminManager instance provided - missing setupAdmin method.');
+            return false;
+        }
+        return true;
+    }
+
+    validateProvidedFrontend()
+    {
+        if(!this.frontend){
+            return false;
+        }
+        if('function' !== typeof this.frontend.initialize){
+            Logger.critical('Invalid frontend instance provided - missing initialize method.');
+            return false;
+        }
+        return true;
     }
 
     loadConfigFromEnv()
     {
         let envVars = process.env;
         return {
-            host: sc.get(envVars, 'RELDENS_CMS_HOST', 'http://localhost'),
-            port: Number(sc.get(envVars, 'RELDENS_CMS_PORT', 8000)),
-            adminPath: sc.get(envVars, 'RELDENS_CMS_ADMIN_PATH', '/reldens-admin'),
-            adminSecret: sc.get(envVars, 'RELDENS_CMS_ADMIN_SECRET', ''),
+            host: sc.get(envVars, 'RELDENS_APP_HOST', 'http://localhost'),
+            port: Number(sc.get(envVars, 'RELDENS_APP_PORT', 8080)),
+            adminPath: sc.get(envVars, 'RELDENS_ADMIN_ROUTE_PATH', '/reldens-admin'),
+            adminSecret: sc.get(envVars, 'RELDENS_ADMIN_SECRET', ''),
             database: {
-                client: sc.get(envVars, 'RELDENS_CMS_DB_CLIENT', 'mysql'),
-                host: sc.get(envVars, 'RELDENS_CMS_DB_HOST', 'localhost'),
-                port: Number(sc.get(envVars, 'RELDENS_CMS_DB_PORT', 3306)),
-                name: sc.get(envVars, 'RELDENS_CMS_DB_NAME', 'reldens_cms'),
-                user: sc.get(envVars, 'RELDENS_CMS_DB_USER', ''),
-                password: sc.get(envVars, 'RELDENS_CMS_DB_PASSWORD', ''),
-                driver: sc.get(envVars, 'RELDENS_CMS_DB_DRIVER', 'prisma')
+                client: sc.get(envVars, 'RELDENS_DB_CLIENT', 'mysql'),
+                host: sc.get(envVars, 'RELDENS_DB_HOST', 'localhost'),
+                port: Number(sc.get(envVars, 'RELDENS_DB_PORT', 3306)),
+                name: sc.get(envVars, 'RELDENS_DB_NAME', 'reldens_cms'),
+                user: sc.get(envVars, 'RELDENS_DB_USER', ''),
+                password: sc.get(envVars, 'RELDENS_DB_PASSWORD', ''),
+                driver: sc.get(envVars, 'RELDENS_STORAGE_DRIVER', 'prisma')
             }
         };
     }
@@ -69,57 +154,115 @@ class Manager
 
     async start()
     {
-        let createdAppServer = this.appServerFactory.createAppServer();
-        if(this.appServerFactory.error.message){
-            Logger.error('App server error: '+this.appServerFactory.error.message);
-            return false;
+        if(!this.useProvidedServer){
+            let createdAppServer = this.appServerFactory.createAppServer();
+            if(this.appServerFactory.error.message){
+                Logger.error('App server error: '+this.appServerFactory.error.message);
+                return false;
+            }
+            this.app = createdAppServer.app;
+            this.appServer = createdAppServer.appServer;
         }
-        this.app = createdAppServer.app;
-        this.appServer = createdAppServer.appServer;
         if(!this.isInstalled()){
             Logger.info('CMS not installed, preparing setup');
             await this.installer.prepareSetup(this.app, this.appServer, this.appServerFactory);
-            await this.appServer.listen(this.config.port);
+            if(!this.useProvidedServer){
+                await this.appServer.listen(this.config.port);
+            }
             Logger.info('Installer running on '+this.config.host+':'+this.config.port);
             return true;
         }
         try {
-            await this.initializeDataServer();
-            await this.initializeAdminManager();
-            await this.initializeFrontend();
-            await this.appServer.listen(this.config.port);
+            await this.initializeServices();
             Logger.info('CMS running on '+this.config.host+':'+this.config.port);
             return true;
         } catch (error) {
-            Logger.error('Failed to start CMS: '+error.message);
+            Logger.critical('Failed to start CMS: '+error.message);
             return false;
         }
     }
 
-    async initializeCmsAfterInstall(entitiesData)
+    async initializeCmsAfterInstall(props)
     {
         try {
-            if(entitiesData){
-                this.entities = sc.get(entitiesData, 'entities', this.entities);
-                this.rawEntities = sc.get(entitiesData, 'rawEntities', this.rawEntities);
-                this.entitiesConfig = sc.get(entitiesData, 'entitiesConfig', this.entitiesConfig);
-                this.entitiesTranslations = sc.get(entitiesData, 'entitiesTranslations', this.entitiesTranslations);
+            //Logger.debug('Loaded entities post install.', props.loadedEntities);
+            this.rawRegisteredEntities = props.loadedEntities.rawRegisteredEntities;
+            this.entitiesTranslations = props.loadedEntities.entitiesTranslations;
+            this.entitiesConfig = props.loadedEntities.entitiesConfig;
+            this.config = props.mappedVariablesForConfig;
+            await this.initializeServices();
+            Logger.info('CMS initialized after installation on '+this.config.host+':'+this.config.port);
+            return true;
+        } catch (error) {
+            Logger.critical('Failed to initialize CMS after installation: '+error.message);
+            return false;
+        }
+    }
+
+    async initializeServices()
+    {
+        if(!this.useProvidedDataServer){
+            if(!await this.initializeDataServer()){
+                return false;
             }
-            this.config = this.loadConfigFromEnv();
-            if(this.appServerFactory.error.message){
-                Logger.critical('App server creation failed: '+this.appServerFactory.error.message);
+        }
+        if(!this.loadProcessedEntities()){
+            return false;
+        }
+        if(!await this.generateAdminEntities()){
+            return false;
+        }
+        if(!this.useProvidedAdminManager){
+            if(!await this.initializeAdminManager()){
+                return false;
+            }
+        }
+        if(!this.useProvidedFrontend){
+            if(!await this.initializeFrontend()){
                 return false;
             }
-            await this.initializeDataServer();
-            await this.initializeAdminManager();
-            await this.initializeFrontend();
+        }
+        if(!this.useProvidedServer){
             await this.appServer.listen(this.config.port);
-            Logger.info('CMS initialized after installation on '+this.config.host+':'+this.config.port);
+        }
+        return true;
+    }
+
+    loadProcessedEntities()
+    {
+        if(0 === Object.keys(this.processedEntities).length){
+            this.processedEntities = LoadedEntitiesProcessor.process(
+                this.rawRegisteredEntities,
+                this.entitiesTranslations,
+                this.entitiesConfig
+            );
+        }
+        if(!this.processedEntities?.entities){
+            Logger.critical('Processed entities undefined.');
+            return false;
+        }
+        return true;
+    }
+
+    async generateAdminEntities()
+    {
+        if(0 < Object.keys(this.adminEntities).length){
             return true;
-        } catch (error) {
-            Logger.critical('Failed to initialize CMS after installation: '+error.message);
+        }
+        if(!this.dataServer.rawEntities && this.rawRegisteredEntities){
+            this.dataServer.rawEntities = this.rawRegisteredEntities;
+        }
+        Logger.debug('Generate entities count: '+Object.keys(this.rawRegisteredEntities).length);
+        await this.dataServer.generateEntities();
+        this.adminEntities = this.adminEntitiesGenerator.generate(
+            this.processedEntities.entities,
+            this.dataServer.entityManager.entities
+        );
+        if(0 === Object.keys(this.adminEntities).length){
+            Logger.warning('Admin entities not found.');
             return false;
         }
+        return true;
     }
 
     async initializeDataServer()
@@ -133,7 +276,7 @@ class Manager
                 user: this.config.database.user,
                 password: this.config.database.password
             },
-            rawEntities: this.rawEntities
+            rawEntities: this.rawRegisteredEntities
         };
         let DriverClass = DriversMap[this.config.database.driver];
         if(!DriverClass){
@@ -145,6 +288,7 @@ class Manager
             Logger.critical('Failed to connect to database.');
             return false;
         }
+        Logger.debug('Entities count: '+Object.keys(this.rawRegisteredEntities).length);
         await this.dataServer.generateEntities();
         return true;
     }
@@ -152,35 +296,58 @@ class Manager
     async initializeAdminManager()
     {
         let authenticationCallback = this.authenticationCallback;
-        if('db-users' === this.authenticationMethod){
+        if('db-users' === this.authenticationMethod && !authenticationCallback){
             authenticationCallback = async (email, password, roleId) => {
+                Logger.debug('Running default "db-users" authentication.');
                 let usersEntity = this.dataServer.getEntity('users');
                 if(!usersEntity){
+                    Logger.critical('No users entity found.');
                     return false;
                 }
                 let user = await usersEntity.loadOneBy('email', email);
                 if(!user){
+                    Logger.debug('User not found by email: '+email+'.', user);
                     return false;
                 }
                 if(Number(user.role_id) !== Number(roleId)){
+                    Logger.debug('Invalid user role ID: '+roleId+' / '+user.role_id+'.');
                     return false;
                 }
-                return Encryptor.validatePassword(password, user.password) ? user : false;
+                let passwordResult = Encryptor.validatePassword(password, user.password) ? user : false;
+                if(!passwordResult){
+                    Logger.debug('Invalid user password for: '+email+'.');
+                }
+                return passwordResult;
             };
         }
         let adminConfig = {
             events: this.events,
-            renderCallback: this.renderCallback.bind(this),
             dataServer: this.dataServer,
             authenticationCallback,
             app: this.app,
             appServerFactory: this.appServerFactory,
+            entities: this.adminEntities,
+            validator: new AdminManagerValidator(),
+            renderCallback: this.renderCallback.bind(this),
             secret: this.config.adminSecret,
             rootPath: this.config.adminPath,
-            adminRoleId: 99,
-            entities: this.entities,
-            entitiesConfig: this.entitiesConfig,
-            translations: this.entitiesTranslations
+            translations: AdminTranslations.appendTranslations(this.entitiesTranslations || {}),
+            adminFilesContents: await AdminTemplatesLoader.fetchAdminFilesContents(
+                TemplatesToPathMapper.map(this.adminTemplatesList, this.projectAdminTemplatesPath)
+            ),
+            mimeTypes: this.mimeTypes,
+            allowedExtensions: this.allowedExtensions,
+            adminRoleId: this.adminRoleId,
+            stylesFilePath: this.stylesFilePath,
+            scriptsFilePath: this.scriptsFilePath,
+            branding: {
+                companyName: this.companyName,
+                logo: this.logo,
+                favicon: this.favicon,
+                copyRight: await FileHandler.fetchFileContents(
+                    FileHandler.joinPaths(this.projectAdminTemplatesPath, this.adminTemplatesList.defaultCopyRight)
+                )
+            }
         };
         this.adminManager = new AdminManager(adminConfig);
         await this.adminManager.setupAdmin();

package/lib/mime-types.js

@@ -0,0 +1,35 @@
+/**
+ *
+ * Reldens - MimeTypes
+ *
+ */
+
+module.exports.MimeTypes = {
+    audio: [
+        'audio/aac',
+        'audio/midi',
+        'audio/x-midi',
+        'audio/mpeg',
+        'audio/ogg',
+        'application/ogg',
+        'audio/opus',
+        'audio/wav',
+        'audio/webm',
+        'audio/3gpp2'
+    ],
+    image: [
+        'image/bmp',
+        'image/gif',
+        'image/jpeg',
+        'image/png',
+        'image/svg+xml',
+        'image/vnd.microsoft.icon',
+        'image/tiff',
+        'image/webp'
+    ],
+    text: [
+        'application/json',
+        'application/ld+json',
+        'text/plain',
+    ]
+};

package/lib/templates-list.js

@@ -8,10 +8,6 @@ module.exports.TemplatesList = {
     login: 'login.html',
     dashboard: 'dashboard.html',
     management: 'management.html',
-    mapsWizard: 'maps-wizard.html',
-    mapsWizardMapsSelection: 'maps-wizard-maps-selection.html',
-    objectsImport: 'objects-import.html',
-    skillsImport: 'skills-import.html',
     list: 'list.html',
     listContent: 'list-content.html',
     view: 'view.html',
@@ -41,10 +37,5 @@ module.exports.TemplatesList = {
             button: 'button.html',
             file: 'file.html'
         }
-    },
-    sections: {
-        view: {
-            rooms: 'rooms.html'
-        }
     }
 };

package/lib/templates-to-path-mapper.js

@@ -0,0 +1,28 @@
+/**
+ *
+ * Reldens - TemplatesToPathMapper
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+
+class TemplatesToPathMapper
+{
+
+    map(templateList, path)
+    {
+        let result = {};
+        for(let templateName of Object.keys(templateList)){
+            if(sc.isObject(templateList[templateName])){
+                result[templateName] = this.map(templateList[templateName], FileHandler.joinPaths(path, templateName));
+                continue;
+            }
+            result[templateName] = FileHandler.joinPaths(path, templateList[templateName]);
+        }
+        return result;
+    }
+
+}
+
+module.exports.TemplatesToPathMapper = new TemplatesToPathMapper();

package/migrations/default-homepage.sql

@@ -0,0 +1,10 @@
+
+-- Default homepage:
+
+-- Create a default homepage route if not exists
+REPLACE INTO `cms_pages` (`id`, `title`, `content`, `template`, `created_at`) VALUES
+(1, 'Home', '<h1>Welcome to Reldens CMS</h1><p>This is your homepage. Edit this content in the admin panel.</p>', 'page', NOW());
+
+-- Create a default route to the homepage
+REPLACE INTO `routes` (`id`, `path`, `router`, `content_id`, `title`, `meta_description`, `status`, `created_at`) VALUES
+(1, '/home', 'cmsPages', 1, 'Home', 'Welcome to Reldens CMS', 'published', NOW());

package/migrations/install.sql

@@ -1,19 +1,5 @@
 
--- Install SQL for Reldens CMS
-
-CREATE TABLE IF NOT EXISTS `users` (
-    `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
-    `email` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `username` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `password` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `role_id` INT(10) UNSIGNED NOT NULL,
-    `status` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `created_at` TIMESTAMP NOT NULL DEFAULT (NOW()),
-    `updated_at` TIMESTAMP NOT NULL DEFAULT (NOW()) ON UPDATE CURRENT_TIMESTAMP,
-    PRIMARY KEY (`id`) USING BTREE,
-    UNIQUE KEY `email` (`email`) USING BTREE,
-    UNIQUE KEY `username` (`username`) USING BTREE
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+-- Install Reldens CMS
 
 CREATE TABLE IF NOT EXISTS `routes` (
     `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
@@ -74,11 +60,3 @@ CREATE TABLE IF NOT EXISTS `entities_meta` (
     PRIMARY KEY (`id`) USING BTREE,
     UNIQUE KEY `entity_meta` (`entity_name`, `entity_id`, `meta_key`) USING BTREE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-
--- Create a default homepage route if not exists
-INSERT IGNORE INTO `cms_pages` (`id`, `title`, `content`, `template`, `created_at`) VALUES
-(1, 'Home', '<h1>Welcome to Reldens CMS</h1><p>This is your homepage. Edit this content in the admin panel.</p>', 'page', NOW());
-
--- Create a default route to the homepage
-INSERT IGNORE INTO `routes` (`path`, `router`, `content_id`, `title`, `meta_description`, `status`, `created_at`) VALUES
-('/home', 'cms_pages', 1, 'Home', 'Welcome to Reldens CMS', 'published', NOW());

package/migrations/users-authentication.sql

@@ -0,0 +1,16 @@
+
+-- Default db-users authentication:
+
+CREATE TABLE IF NOT EXISTS `users` (
+    `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
+    `email` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+    `username` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+    `password` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+    `role_id` INT(10) UNSIGNED NOT NULL,
+    `status` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+    `created_at` TIMESTAMP NOT NULL DEFAULT (NOW()),
+    `updated_at` TIMESTAMP NOT NULL DEFAULT (NOW()) ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY (`id`) USING BTREE,
+    UNIQUE KEY `email` (`email`) USING BTREE,
+    UNIQUE KEY `username` (`username`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/cms",
     "scope": "@reldens",
-    "version": "0.6.0",
+    "version": "0.8.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -33,7 +33,7 @@
     },
     "dependencies": {
         "@reldens/server-utils": "^0.16.0",
-        "@reldens/storage": "^0.43.0",
+        "@reldens/storage": "^0.45.0",
         "@reldens/utils": "^0.47.0",
         "dotenv": "^16.5.0",
         "mustache": "^4.2.0"

package/templates/.env.dist

@@ -1,16 +1,16 @@
 # Database Configuration
-RELDENS_CMS_DB_CLIENT={{&dbClient}}
-RELDENS_CMS_DB_HOST={{&dbHost}}
-RELDENS_CMS_DB_PORT={{&dbPort}}
-RELDENS_CMS_DB_NAME={{&dbName}}
-RELDENS_CMS_DB_USER={{&dbUser}}
-RELDENS_CMS_DB_PASSWORD={{&dbPassword}}
-RELDENS_CMS_DB_DRIVER={{&dbDriver}}
+RELDENS_DB_CLIENT={{&dbClient}}
+RELDENS_DB_HOST={{&dbHost}}
+RELDENS_DB_PORT={{&dbPort}}
+RELDENS_DB_NAME={{&dbName}}
+RELDENS_DB_USER={{&dbUser}}
+RELDENS_DB_PASSWORD={{&dbPassword}}
+RELDENS_DB_DRIVER={{&dbDriver}}
 
 # Admin Panel Configuration
-RELDENS_CMS_ADMIN_PATH={{&adminPath}}
-RELDENS_CMS_ADMIN_SECRET={{&adminSecret}}
+RELDENS_ADMIN_ROUTE_PATH={{&adminPath}}
+RELDENS_ADMIN_SECRET={{&adminSecret}}
 
 # Server Configuration
-RELDENS_CMS_HOST={{&host}}
-RELDENS_CMS_PORT={{&port}}
+RELDENS_APP_HOST={{&host}}
+RELDENS_APP_PORT={{&port}}