@reldens/cms 0.7.0 → 0.9.0

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');
 
@@ -104,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.'
@@ -157,39 +157,32 @@ 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);
@@ -198,7 +191,10 @@ class Installer
                     await this.appServer.close();
                 }
                 Logger.debug('Running postInstallCallback.');
-                await this.postInstallCallback(this.entitiesLoader.loadEntities(selectedDriver));
+                await this.postInstallCallback({
+                    loadedEntities: this.entitiesLoader.loadEntities(selectedDriver),
+                    mappedVariablesForConfig
+                });
             }
             await this.createLockFile();
             Logger.info('Installation successful!');
@@ -214,13 +210,23 @@ class Installer
         }
     }
 
-    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)
@@ -252,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)
@@ -328,18 +357,20 @@ class Installer
         FileHandler.createFolder(this.projectPublicAssetsPath);
         FileHandler.createFolder(this.projectCssPath);
         FileHandler.createFolder(this.projectJsPath);
-        FileHandler.copyFile(
-            FileHandler.joinPaths(this.defaultTemplatesPath, 'page.html'),
-            FileHandler.joinPaths(this.projectTemplatesPath, 'page.html')
-        );
-        FileHandler.copyFile(
-            FileHandler.joinPaths(this.defaultTemplatesPath, '404.html'),
-            FileHandler.joinPaths(this.projectTemplatesPath, '404.html')
-        );
-        FileHandler.copyFile(
-            FileHandler.joinPaths(this.defaultTemplatesPath, 'layout.html'),
-            FileHandler.joinPaths(this.projectTemplatesPath, 'layout.html')
-        );
+        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(this.projectCssPath, 'styles.css')
@@ -354,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/manager.js

@@ -51,35 +51,98 @@ class Manager
         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')
             }
         };
     }
@@ -91,17 +154,21 @@ 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;
         }
@@ -115,14 +182,14 @@ class Manager
         }
     }
 
-    async initializeCmsAfterInstall(loadEntities)
+    async initializeCmsAfterInstall(props)
     {
         try {
-            this.rawRegisteredEntities = loadEntities.rawRegisteredEntities;
-            this.entitiesTranslations = loadEntities.entitiesTranslations;
-            this.entitiesConfig = loadEntities.entitiesConfig;
-            this.dataServer.rawEntities = loadEntities.rawRegisteredEntities;
-            this.config = this.loadConfigFromEnv();
+            //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;
@@ -134,28 +201,68 @@ class Manager
 
     async initializeServices()
     {
-        await this.initializeDataServer();
-        if (0 === Object.keys(this.adminEntities).length){
-            if(0 === Object.keys(this.processedEntities).length){
-                this.processedEntities = LoadedEntitiesProcessor.process(
-                    this.rawRegisteredEntities,
-                    this.entitiesTranslations,
-                    this.entitiesConfig
-                );
+        if(!this.useProvidedDataServer){
+            if(!await this.initializeDataServer()){
+                return false;
+            }
+        }
+        if(!this.loadProcessedEntities()){
+            return false;
+        }
+        if(!await this.generateAdminEntities()){
+            return false;
+        }
+        if(!this.useProvidedAdminManager){
+            if(!await this.initializeAdminManager()){
+                return false;
             }
-            if(!this.processedEntities.entities){
-                Logger.critical('Processed entities undefined.');
+        }
+        if(!this.useProvidedFrontend){
+            if(!await this.initializeFrontend()){
                 return false;
             }
-            await this.dataServer.generateEntities();
-            this.adminEntities = this.adminEntitiesGenerator.generate(
-                this.processedEntities.entities,
-                this.dataServer.entityManager.entities
+        }
+        if(!this.useProvidedServer){
+            await this.appServer.listen(this.config.port);
+        }
+        return true;
+    }
+
+    loadProcessedEntities()
+    {
+        if(0 === Object.keys(this.processedEntities).length){
+            this.processedEntities = LoadedEntitiesProcessor.process(
+                this.rawRegisteredEntities,
+                this.entitiesTranslations,
+                this.entitiesConfig
             );
         }
-        await this.initializeAdminManager();
-        await this.initializeFrontend();
-        await this.appServer.listen(this.config.port);
+        if(!this.processedEntities?.entities){
+            Logger.critical('Processed entities undefined.');
+            return false;
+        }
+        return true;
+    }
+
+    async generateAdminEntities()
+    {
+        if(0 < Object.keys(this.adminEntities).length){
+            return true;
+        }
+        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()
@@ -181,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;
     }

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.7.0",
+    "version": "0.9.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -32,8 +32,8 @@
         "url": "https://github.com/damian-pastorini/reldens-cms/issues"
     },
     "dependencies": {
-        "@reldens/server-utils": "^0.16.0",
-        "@reldens/storage": "^0.44.0",
+        "@reldens/server-utils": "^0.17.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}}