@reldens/cms 0.4.0 → 0.6.0

package/lib/installer.js

@@ -6,6 +6,8 @@
 
 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');
 
@@ -15,6 +17,7 @@ class Installer
     constructor(props)
     {
         this.app = sc.get(props, 'app', false);
+        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');
@@ -24,6 +27,11 @@ class Installer
         this.installerPath = FileHandler.joinPaths(this.modulePath, 'install');
         this.migrationsPath = FileHandler.joinPaths(this.modulePath, 'migrations');
         this.defaultTemplatesPath = FileHandler.joinPaths(this.modulePath, 'templates');
+        this.moduleAdminPath = FileHandler.joinPaths(this.modulePath, 'admin');
+        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()
@@ -31,7 +39,7 @@ class Installer
         return FileHandler.exists(this.installLockPath);
     }
 
-    async prepareSetup(app, appServerFactory)
+    async prepareSetup(app, appServer, appServerFactory)
     {
         if(!app){
             Logger.error('Missing app on prepareSetup for Installer.');
@@ -43,6 +51,7 @@ class Installer
         }
         this.app = app;
         this.appServerFactory = appServerFactory;
+        this.appServer = appServer;
         app.use('/install-assets', appServerFactory.applicationFramework.static(this.installerPath, {index: false}));
         app.use(appServerFactory.session({
             secret: Encryptor.generateSecretKey(),
@@ -63,17 +72,44 @@ class Installer
         if(this.isInstalled()){
             return next();
         }
-        if('' === req._parsedUrl.pathname || '/' === req._parsedUrl.pathname){
+        let urlPath = req._parsedUrl.pathname;
+        if('' === urlPath || '/' === urlPath){
             let installerIndexPath = FileHandler.joinPaths(this.installerPath, 'index.html');
             if(!FileHandler.exists(installerIndexPath)){
                 return res.status(500).send('Installer template not found.');
             }
             let content = FileHandler.readFile(installerIndexPath);
-            return res.send(mustache.render(content, req.session?.templateVariables || this.fetchDefaults()));
+            let contentParams = req.session?.templateVariables || this.fetchDefaults();
+            let errorParam = req.query?.error;
+            if(errorParam){
+                contentParams.errorMessage = this.getErrorMessage(errorParam);
+            }
+            return res.send(mustache.render(content, contentParams));
+        }
+        if('/install' !== urlPath){
+            return res.redirect('/');
         }
         next();
     }
 
+    getErrorMessage(errorCode)
+    {
+        let errorMessages = {
+            'invalid-driver': 'Invalid storage driver selected.',
+            '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-default-user-error': 'Failed to create default user.',
+            '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.'
+        };
+        return errorMessages[errorCode] || 'An unknown error occurred during installation.';
+    }
+
     async executeInstallProcess(req, res)
     {
         if(this.isInstalled()){
@@ -117,30 +153,71 @@ class Installer
             Logger.error('SQL installation file not found.');
             return res.redirect('/?error=sql-file-not-found');
         }
-        await this.executeQueryFile(dbDriver, installSqlPath);
+        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)){
-                await this.executeQueryFile(dbDriver, 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.');
             }
-            await this.generateEntities(dbDriver);
+            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.');
         } catch (error) {
             Logger.error('Installation error: '+error.message);
             return res.redirect('/?error=installation-process-failed');
         }
-        if('' === templateVariables['app-admin-path']){
-            templateVariables['app-admin-path'] = '/reldens-admin';
-        }
         try {
             await this.createEnvFile(templateVariables);
-            await this.createLockFile();
             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 || {}
+                    });
+                }
+            }
+            await this.createLockFile();
             Logger.info('Installation successful!');
-            let adminPath = templateVariables['app-admin-path'];
-            return res.redirect(adminPath);
+            let successContent = 'Installation successful! Run "node ." to start your CMS.';
+            let successFileContent = FileHandler.readFile(FileHandler.joinPaths(this.installerPath, 'success.html'));
+            if(successFileContent){
+                successContent = mustache.render(successFileContent, {adminPath: templateVariables['app-admin-path']});
+            }
+            return res.send(successContent);
         } catch (error) {
             Logger.error('Configuration error: '+error.message);
             return res.redirect('/?error=configuration-error');
@@ -200,56 +277,80 @@ class Installer
             dbDriver: templateVariables['db-storage-driver'],
             adminPath: templateVariables['app-admin-path'],
             adminSecret: Encryptor.generateSecretKey(),
-            host: templateVariables['app-host'] || 'http://localhost',
-            port: templateVariables['app-port'] || '3000'
+            host: templateVariables['app-host'],
+            port: templateVariables['app-port']
         });
         return FileHandler.writeFile(this.envFilePath, envContent);
     }
 
+    async createIndexJsFile(templateVariables)
+    {
+        if(!FileHandler.exists(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 = mustache.render(indexTemplate, {driverKey});
+        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.');
+            return true;
+        }
+        return FileHandler.writeFile(indexFilePath, indexContent);
+    }
+
     async createLockFile()
     {
-        return FileHandler.writeFile(this.installLockPath,
-            'Installation completed on '+new Date().toISOString());
+        return FileHandler.writeFile(this.installLockPath, 'Installation completed on '+new Date().toISOString());
+    }
+
+    async copyAdminDirectory()
+    {
+        let projectAdminPath = FileHandler.joinPaths(this.projectRoot, 'admin');
+        if(FileHandler.exists(projectAdminPath)){
+            Logger.info('Admin folder already exists in project root.');
+            return true;
+        }
+        if(!FileHandler.exists(this.moduleAdminPath)){
+            Logger.error('Admin folder not found in module path: '+this.moduleAdminPath);
+            return false;
+        }
+        FileHandler.copyFolderSync(this.moduleAdminPath, projectAdminPath);
+        Logger.info('Admin folder copied to project root.');
+        return true;
     }
 
     async prepareProjectDirectories()
     {
         let projectTemplatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
-        if(!FileHandler.exists(projectTemplatesPath)){
-            FileHandler.createFolder(projectTemplatesPath);
-        }
+        FileHandler.createFolder(projectTemplatesPath);
         let projectPublicPath = FileHandler.joinPaths(this.projectRoot, 'public');
-        if(!FileHandler.exists(projectPublicPath)){
-            FileHandler.createFolder(projectPublicPath);
-        }
+        FileHandler.createFolder(projectPublicPath);
         let projectCssPath = FileHandler.joinPaths(projectPublicPath, 'css');
-        if(!FileHandler.exists(projectCssPath)){
-            FileHandler.createFolder(projectCssPath);
-        }
+        FileHandler.createFolder(projectCssPath);
         let projectJsPath = FileHandler.joinPaths(projectPublicPath, 'js');
-        if(!FileHandler.exists(projectJsPath)){
-            FileHandler.createFolder(projectJsPath);
-        }
-        let defaultPagePath = FileHandler.joinPaths(this.defaultTemplatesPath, 'page.html');
-        let defaultNotFoundPath = FileHandler.joinPaths(this.defaultTemplatesPath, '404.html');
-        let defaultLayoutPath = FileHandler.joinPaths(this.defaultTemplatesPath, 'layout.html');
-        if(FileHandler.exists(defaultPagePath)){
-            FileHandler.copyFile(defaultPagePath, FileHandler.joinPaths(projectTemplatesPath, 'page.html'));
-        }
-        if(FileHandler.exists(defaultNotFoundPath)){
-            FileHandler.copyFile(defaultNotFoundPath, FileHandler.joinPaths(projectTemplatesPath, '404.html'));
-        }
-        if(FileHandler.exists(defaultLayoutPath)){
-            FileHandler.copyFile(defaultLayoutPath, FileHandler.joinPaths(projectTemplatesPath, 'layout.html'));
-        }
-        let defaultCssPath = FileHandler.joinPaths(this.defaultTemplatesPath, 'css', 'styles.css');
-        let defaultJsPath = FileHandler.joinPaths(this.defaultTemplatesPath, 'js', 'scripts.js');
-        if(FileHandler.exists(defaultCssPath)){
-            FileHandler.copyFile(defaultCssPath, FileHandler.joinPaths(projectCssPath, 'styles.css'));
-        }
-        if(FileHandler.exists(defaultJsPath)){
-            FileHandler.copyFile(defaultJsPath, FileHandler.joinPaths(projectJsPath, 'scripts.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.copyFile(
+            FileHandler.joinPaths(this.defaultTemplatesPath, 'css', 'styles.css'),
+            FileHandler.joinPaths(projectCssPath, 'styles.css')
+        );
+        FileHandler.copyFile(
+            FileHandler.joinPaths(this.defaultTemplatesPath, 'js', 'scripts.js'),
+            FileHandler.joinPaths(projectJsPath, 'scripts.js')
+        );
         return true;
     }
 
@@ -257,7 +358,7 @@ class Installer
     {
         return {
             'app-host': process.env.RELDENS_CMS_HOST || 'http://localhost',
-            'app-port': process.env.RELDENS_CMS_PORT || '3000',
+            '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',

package/lib/manager.js

@@ -8,13 +8,14 @@ const { AppServerFactory, FileHandler, Encryptor } = require('@reldens/server-ut
 const { DriversMap } = require('@reldens/storage');
 const { AdminManager } = require('./admin-manager');
 const { Installer } = require('./installer');
-const { Storefront } = require('./storefront');
-const { Logger, sc } = require('@reldens/utils');
+const { Frontend } = require('./frontend');
+const { EventsManagerSingleton, Logger, sc } = require('@reldens/utils');
 const dotenv = require('dotenv');
 const mustache = require('mustache');
 
 class Manager
 {
+
     constructor(props = {})
     {
         this.projectRoot = sc.get(props, 'projectRoot', './');
@@ -23,34 +24,40 @@ class Manager
         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.entitiesTranslations = sc.get(props, 'entitiesTranslations', {});
         this.authenticationMethod = sc.get(props, 'authenticationMethod', 'db-users');
         this.authenticationCallback = sc.get(props, 'authenticationCallback', false);
+        this.events = sc.get(props, 'events', EventsManagerSingleton);
         this.appServerFactory = new AppServerFactory();
         this.installer = new Installer({
-            projectRoot: this.projectRoot
+            projectRoot: this.projectRoot,
+            postInstallCallback: this.initializeCmsAfterInstall.bind(this)
         });
         this.dataServer = false;
         this.app = false;
         this.appServer = false;
         this.adminManager = false;
-        this.storefront = false;
+        this.frontend = false;
     }
 
     loadConfigFromEnv()
     {
+        let envVars = process.env;
         return {
-            host: process.env.RELDENS_CMS_HOST || 'http://localhost',
-            port: Number(process.env.RELDENS_CMS_PORT || 3000),
-            adminPath: process.env.RELDENS_CMS_ADMIN_PATH || '/reldens-admin',
-            adminSecret: process.env.RELDENS_CMS_ADMIN_SECRET || '',
+            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', ''),
             database: {
-                client: process.env.RELDENS_CMS_DB_CLIENT || 'mysql',
-                host: process.env.RELDENS_CMS_DB_HOST || 'localhost',
-                port: Number(process.env.RELDENS_CMS_DB_PORT || 3306),
-                name: process.env.RELDENS_CMS_DB_NAME || 'reldens_cms',
-                user: process.env.RELDENS_CMS_DB_USER || '',
-                password: process.env.RELDENS_CMS_DB_PASSWORD || '',
-                driver: process.env.RELDENS_CMS_DB_DRIVER || 'prisma'
+                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')
             }
         };
     }
@@ -71,7 +78,7 @@ class Manager
         this.appServer = createdAppServer.appServer;
         if(!this.isInstalled()){
             Logger.info('CMS not installed, preparing setup');
-            await this.installer.prepareSetup(this.app, this.appServerFactory);
+            await this.installer.prepareSetup(this.app, this.appServer, this.appServerFactory);
             await this.appServer.listen(this.config.port);
             Logger.info('Installer running on '+this.config.host+':'+this.config.port);
             return true;
@@ -79,7 +86,7 @@ class Manager
         try {
             await this.initializeDataServer();
             await this.initializeAdminManager();
-            await this.initializeStorefront();
+            await this.initializeFrontend();
             await this.appServer.listen(this.config.port);
             Logger.info('CMS running on '+this.config.host+':'+this.config.port);
             return true;
@@ -89,6 +96,32 @@ class Manager
         }
     }
 
+    async initializeCmsAfterInstall(entitiesData)
+    {
+        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);
+            }
+            this.config = this.loadConfigFromEnv();
+            if(this.appServerFactory.error.message){
+                Logger.critical('App server creation failed: '+this.appServerFactory.error.message);
+                return false;
+            }
+            await this.initializeDataServer();
+            await this.initializeAdminManager();
+            await this.initializeFrontend();
+            await this.appServer.listen(this.config.port);
+            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 initializeDataServer()
     {
         let dbConfig = {
@@ -99,15 +132,18 @@ class Manager
                 database: this.config.database.name,
                 user: this.config.database.user,
                 password: this.config.database.password
-            }
+            },
+            rawEntities: this.rawEntities
         };
         let DriverClass = DriversMap[this.config.database.driver];
         if(!DriverClass){
-            throw new Error('Invalid database driver: '+this.config.database.driver);
+            Logger.critical('Invalid database driver: '+this.config.database.driver);
+            return false;
         }
         this.dataServer = new DriverClass(dbConfig);
         if(!await this.dataServer.connect()){
-            throw new Error('Failed to connect to database');
+            Logger.critical('Failed to connect to database.');
+            return false;
         }
         await this.dataServer.generateEntities();
         return true;
@@ -133,7 +169,7 @@ class Manager
             };
         }
         let adminConfig = {
-            events: false,
+            events: this.events,
             renderCallback: this.renderCallback.bind(this),
             dataServer: this.dataServer,
             authenticationCallback,
@@ -142,7 +178,9 @@ class Manager
             secret: this.config.adminSecret,
             rootPath: this.config.adminPath,
             adminRoleId: 99,
-            entities: this.entities
+            entities: this.entities,
+            entitiesConfig: this.entitiesConfig,
+            translations: this.entitiesTranslations
         };
         this.adminManager = new AdminManager(adminConfig);
         await this.adminManager.setupAdmin();
@@ -157,14 +195,15 @@ class Manager
         return mustache.render(template, params);
     }
 
-    async initializeStorefront()
+    async initializeFrontend()
     {
-        this.storefront = new Storefront({
+        this.frontend = new Frontend({
             app: this.app,
             dataServer: this.dataServer,
-            projectRoot: this.projectRoot
+            projectRoot: this.projectRoot,
+            appServerFactory: this.appServerFactory
         });
-        return await this.storefront.initialize();
+        return await this.frontend.initialize();
     }
 }
 

package/migrations/default-user.sql

@@ -1,8 +1,9 @@
 
 -- Default admin user:
 
-INSERT IGNORE INTO `users` (`email`, `username`, `password`, `role_id`, `status`)
+REPLACE INTO `users` (`id`, `email`, `username`, `password`, `role_id`, `status`)
 VALUES (
+    1,
    'root@cms-admin.com',
    'root',
    'd35ed1c81c3ff00de15309fe40a90c32:a39a9231a69fefef274c13c1780a7447672a5fee8250ce22a51bb20275039dda63a54faa1e5fd775becb3ac424f571d5b996001305bb7d63e038111dce08d45b',

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/cms",
     "scope": "@reldens",
-    "version": "0.4.0",
+    "version": "0.6.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -33,7 +33,7 @@
     },
     "dependencies": {
         "@reldens/server-utils": "^0.16.0",
-        "@reldens/storage": "^0.37.0",
+        "@reldens/storage": "^0.43.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_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}}
 
 # Admin Panel Configuration
-RELDENS_CMS_ADMIN_PATH={{adminPath}}
-RELDENS_CMS_ADMIN_SECRET={{adminSecret}}
+RELDENS_CMS_ADMIN_PATH={{&adminPath}}
+RELDENS_CMS_ADMIN_SECRET={{&adminSecret}}
 
 # Server Configuration
-RELDENS_CMS_HOST={{host}}
-RELDENS_CMS_PORT={{port}}
+RELDENS_CMS_HOST={{&host}}
+RELDENS_CMS_PORT={{&port}}

package/templates/css/styles.css

@@ -1,4 +1,4 @@
-/* Storefront styles */
+/* Frontend styles */
 body {
     font-family: 'Open Sans', sans-serif;
     line-height: 1.6;

package/templates/index.js.dist

@@ -0,0 +1,32 @@
+/**
+ *
+ * Reldens - CMS
+ *
+ */
+
+const { Manager } = require('@reldens/cms');
+const { Logger } = require('@reldens/utils');
+const { rawRegisteredEntities, entitiesConfig, entitiesTranslations } = require('./generated-entities/models/{{driverKey}}/registered-models-{{driverKey}}');
+
+let args = process.argv.slice(2);
+let projectRoot = args[0] || process.cwd();
+
+let manager = new Manager({
+    projectRoot,
+    entities: rawRegisteredEntities,
+    entitiesConfig,
+    entitiesTranslations
+});
+Logger.debug('Reldens CMS Manager instance created.', {configuration: manager.config});
+
+manager.start().then((result) => {
+    if(!result){
+        Logger.info('Reldens CMS started by command failed.');
+        return false;
+    }
+    Logger.info('Reldens CMS started by command.');
+    return true;
+}).catch((error) => {
+    Logger.error('Failed to start CMS: '+error.message);
+    process.exit();
+});

package/templates/js/scripts.js

@@ -1,4 +1,4 @@
-// Storefront JavaScript
+// Frontend JavaScript
 document.addEventListener('DOMContentLoaded', function() {
     // Add active class to current navigation item
     const currentPath = window.location.pathname;