@reldens/cms 0.5.0 → 0.6.0

package/admin/templates/skills-import.html

@@ -0,0 +1,201 @@
+<h2>Skills Import</h2>
+<div class="sub-content objects-import">
+    <div class="sub-content-box">
+        <form class="sub-content-form objects-import-form confirmation-required"
+            name="objects-import-form"
+            id="objects-import-form"
+            action="{{&actionPath}}"
+            method="post"
+            enctype="multipart/form-data">
+            <div class="main-action-container">
+                <p>What would you like to do?</p>
+                <hr/>
+                <button type="button" class="button button-primary set-sample-data">
+                    Set Sample Data in "Generator Data"
+                </button>
+                <p>NOTE: if you already uploaded all your files and never manually removed them from the "generate-data" folder, you don't need to upload the same files again.</p>
+                <div class="input-box">
+                    <label for="generatorJsonFiles">JSON Files</label>
+                    <input type="file" name="generatorJsonFiles" id="generatorJsonFiles" multiple="multiple"/>
+                </div>
+                <hr/>
+                <label for="generatorData">Generator data (if not empty this data field will be used instead of the files):</label>
+                <textarea name="generatorData" id="generatorData" class="generatorData" cols="30" rows="10" placeholder="JSON data for skills import process"></textarea>
+            </div>
+            <div class="submit-container">
+                <input type="submit" class="button button-primary button-objects-import" value="Import"/>
+                <img class="hidden loading" src="/assets/web/loading.gif"/>
+            </div>
+        </form>
+    </div>
+</div>
+<script type="text/javascript">
+    let sampleDataElement = document.querySelector('.set-sample-data');
+    let generatorDataElement = document.querySelector('.generatorData');
+    if(sampleDataElement && generatorDataElement){
+        sampleDataElement.addEventListener('click', () => {
+            generatorDataElement.value = JSON.stringify({
+                "options": {
+                    "removeAll": false,
+                    "override": false,
+                    "update": true
+                },
+                "defaults": {
+                    "properties": {
+                        "autoValidation": 0,
+                        "skillDelay": 1500,
+                        "castTime": 0,
+                        "usesLimit": 0,
+                        "range": 0,
+                        "rangeAutomaticValidation": 1,
+                        "rangePropertyX": "state/x",
+                        "rangePropertyY": "state/y",
+                        "rangeTargetPropertyX": null,
+                        "rangeTargetPropertyY": null,
+                        "allowSelfTarget": 0,
+                        "criticalChance": 0,
+                        "criticalMultiplier": 1,
+                        "criticalFixedValue": 0,
+                        "customData": null
+                    },
+                    "animations": {
+                        "appendSkillKeyOnAnimationImage": true,
+                        "defaults": {
+                            "enabled": true,
+                            "type": "spritesheet",
+                            "frameWidth": 64,
+                            "frameHeight": 70,
+                            "start": 0
+                        },
+                        "bullet": {
+                            "img": "_bullet",
+                            "end": 3,
+                            "repeat": -1,
+                            "frameRate": 1,
+                            "dir": 3
+                        },
+                        "cast": {
+                            "img": "_cast",
+                            "end": 3,
+                            "repeat": -1,
+                            "destroyTime": 2000,
+                            "depthByPlayer": "above"
+
+                        },
+                        "hit": {
+                            "img": "_hit",
+                            "end": 4,
+                            "repeat": 0,
+                            "depthByPlayer": "above"
+                        }
+                    },
+                    "attack": {
+                        "affectedProperty": "stats/hp",
+                        "allowEffectBelowZero": 0,
+                        "applyDirectDamage": 0,
+                        "attackProperties": "stats/atk,stats/stamina,stats/speed",
+                        "defenseProperties": "stats/def,stats/stamina,stats/speed",
+                        "aimProperties": "stats/aim",
+                        "dodgeProperties": "stats/dodge",
+                        "dodgeFullEnabled": 0,
+                        "dodgeOverAimSuccess": 1,
+                        "damageAffected": 0,
+                        "criticalAffected": 0
+                    },
+                    "physicalData": {
+                        "magnitude": 0,
+                        "objectWidth": 0,
+                        "objectHeight": 0,
+                        "validateTargetOnHit": 0
+                    },
+                    "targetEffects": {
+                        "minValue": 0,
+                        "maxValue": 0,
+                        "minProperty": null,
+                        "maxProperty": null
+                    },
+                    "ownerEffects": {
+                        "minValue": 0,
+                        "maxValue": 0,
+                        "minProperty": null,
+                        "maxProperty": null
+                    }
+                },
+                "skills": {
+                    "punch": {
+                        "classPathLevelRelations": {"all": "1"},
+                        "objectsRelations": {"enemy_1": "player", "enemy_2": "player"},
+                        "properties": {
+                            "skillDelay": 1000,
+                            "range": 50,
+                            "criticalChance": 10,
+                            "criticalMultiplier": 2
+                        },
+                        "typeData": {
+                            "key": "attack",
+                            "properties": {
+                                "hitDamage": 3
+                            }
+                        }
+                    },
+                    "throwRock": {
+                        "classPathLevelRelations": {"all": "2"},
+                        "objectsRelations": {"enemy_1": "player", "enemy_2": "player"},
+                        "properties": {
+                            "skillDelay": 2000,
+                            "range": 250,
+                            "criticalChance": 10,
+                            "criticalMultiplier": 2
+                        },
+                        "typeData": {
+                            "key": "physical_attack",
+                            "properties": {
+                                "hitDamage": 5
+                            }
+                        },
+                        "physicalData": {
+                            "magnitude": 350,
+                            "objectWidth": 5,
+                            "objectHeight": 5
+                        }
+                    },
+                    "heal": {
+                        "classPathLevelRelations": {"sorcerer": "3"},
+                        "properties": {
+                            "skillDelay": 1500,
+                            "allowSelfTarget": 1,
+                            "castTime": 2000
+                        },
+                        "typeData": {
+                            "key": "effect"
+                        },
+                        "animations": {
+                            "cast": {},
+                            "hit": {}
+                        },
+                        "clearPrevious": ["targetEffects", "ownerEffects", "ownerConditions"],
+                        "ownerConditions": [{
+                            "key": "available_mp",
+                            "propertyKey": "stats/mp",
+                            "conditional": "ge",
+                            "value": 2
+                        }],
+                        "ownerEffects": [{
+                            "key": "dec_mp",
+                            "propertyKey": "stats/mp",
+                            "operationKey": "2",
+                            "value": 2
+                        }],
+                        "targetEffects": [{
+                            "key": "heal",
+                            "propertyKey": "stats/mp",
+                            "operationKey": "1",
+                            "value": 5,
+                            "maxProperty": "statsBase/hp"
+                        }]
+                    }
+                }
+            });
+        });
+    }
+</script>

package/admin/templates/view.html

@@ -0,0 +1,23 @@
+<div class="entity-view {{&entityName}}-view">
+    <h2>{{&templateTitle}}</h2>
+    {{#fields}}
+    <div class="view-field">
+        <span class="field-name">{{&name}}</span>
+        <span class="field-value">{{&value}}</span>
+    </div>
+    {{/fields}}
+    <div class="actions">
+        <a class="button button-primary" href="{{&entityNewRoute}}">Create New</a>
+        <a class="button button-primary" href="{{&entityEditRoute}}">Edit</a>
+        <a class="button button-secondary" href="{{&entityListRoute}}">Back</a>
+        <form class="form-delete" name="delete-form-{{&id}}" id="delete-form-{{&id}}" action="{{&entityDeleteRoute}}" method="post">
+            <span>
+                <input type="hidden" name="ids[]" value="{{&id}}"/>
+                <button class="button button-danger" type="submit">Delete</button>
+            </span>
+        </form>
+        <div class="extra-actions">
+            {{&extraContent}}
+        </div>
+    </div>
+</div>

package/bin/reldens-cms.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  *
@@ -7,15 +7,27 @@
  */
 
 const { Manager } = require('../index');
+const { Logger } = require('@reldens/utils');
 
 let args = process.argv.slice(2);
-let projectRoot = args[0] || './';
+let projectRoot = args[0] || process.cwd();
 
-let manager = new Manager({
-    projectRoot
-});
+let manager = new Manager({projectRoot});
+Logger.debug('Reldens CMS Manager instance created.', {configuration: manager.config});
 
-manager.start().catch((error) => {
-    console.error('Failed to start CMS:', error);
-    process.exit(1);
+let started =  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);
+    process.exit();
 });
+
+if(!started){
+    Logger.error('Reldens CMS start process failed.');
+    process.exit();
+}

package/index.js

@@ -6,10 +6,10 @@
 
 const { Manager } = require('./lib/manager');
 const { Installer } = require('./lib/installer');
-const { Storefront } = require('./lib/storefront');
+const { Frontend } = require('./lib/frontend');
 
 module.exports = {
     Manager,
     Installer,
-    Storefront
+    Frontend
 };

package/lib/entities-loader.js

@@ -0,0 +1,45 @@
+/**
+ *
+ * Reldens - EntitiesLoader
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+
+class EntitiesLoader
+{
+
+    constructor(props)
+    {
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.generatedEntitiesModelsFolder = FileHandler.joinPaths(this.projectRoot, 'generated-entities', 'models');
+    }
+
+    loadEntities(driverKey)
+    {
+        let entitiesPath = FileHandler.joinPaths(
+            this.generatedEntitiesModelsFolder,
+            driverKey,
+            'registered-models-'+driverKey+'.js'
+        );
+        if(!FileHandler.exists(entitiesPath)){
+            Logger.warning('Entities file not found: ' + entitiesPath);
+            return {};
+        }
+        try {
+            let loadedEntities = require(entitiesPath);
+            return {
+                entities: loadedEntities.entitiesConfig,
+                entitiesRaw: loadedEntities.rawRegisteredEntities,
+                translations: loadedEntities.entitiesTranslations,
+            }
+        } catch(error){
+            Logger.error('Failed to load generated entities: ' + error.message);
+        }
+        return {};
+    }
+
+}
+
+module.exports.EntitiesLoader = EntitiesLoader;

package/lib/{storefront.js → frontend.js}

@@ -1,6 +1,6 @@
 /**
  *
- * Reldens - CMS - Storefront
+ * Reldens - CMS - Frontend
  *
  */
 
@@ -8,12 +8,13 @@ const { FileHandler } = require('@reldens/server-utils');
 const { Logger, sc } = require('@reldens/utils');
 const mustache = require('mustache');
 
-class Storefront
+class Frontend
 {
 
     constructor(props)
     {
         this.app = sc.get(props, 'app', false);
+        this.appServerFactory = sc.get(props, 'appServerFactory', false);
         this.dataServer = sc.get(props, 'dataServer', false);
         this.projectRoot = sc.get(props, 'projectRoot', './');
         this.templatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
@@ -45,11 +46,14 @@ class Storefront
 
     setupStaticAssets()
     {
-        if(!this.app || !this.publicPath){
+        if(!this.app || !this.appServerFactory || !this.publicPath){
             return false;
         }
-        this.app.use(this.app._router.constructor.static(this.publicPath));
-        return true;
+        if(this.appServerFactory && this.appServerFactory.applicationFramework){
+            this.app.use(this.appServerFactory.applicationFramework.static(this.publicPath));
+            return true;
+        }
+        return false;
     }
 
     async handleRequest(req, res)
@@ -225,4 +229,4 @@ class Storefront
 
 }
 
-module.exports.Storefront = Storefront;
+module.exports.Frontend = Frontend;

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,18 +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);
             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()){
@@ -129,7 +164,7 @@ class Installer
             if(FileHandler.exists(defaultUserSqlPath)){
                 let queryUserResult = await this.executeQueryFile(dbDriver, defaultUserSqlPath);
                 if(!queryUserResult){
-                    Logger.error('Default user creation failed.');
+                    Logger.error('Default user creation failed.', queryUserResult);
                     return res.redirect('/?error=sql-default-user-error');
                 }
                 Logger.info('Created default user.');
@@ -144,16 +179,45 @@ class Installer
             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');
@@ -213,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'] || '8000'
+            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;
     }