@reldens/cms 0.16.0 → 0.18.0

package/admin/reldens-admin-client.css

@@ -817,6 +817,17 @@
         }
     }
 
+    .extra-actions {
+        display: block;
+        width: 100%;
+        margin-top: 2rem;
+    }
+
+    .cache-clean-form {
+        display: block;
+        text-align: center;
+    }
+
     & .extra-content-container, .default-room-container {
         display: flex;
         flex-direction: column;

package/admin/templates/cache-clean-button.html

@@ -0,0 +1,4 @@
+<form class="cache-clean-form" method="POST" action="{{&cacheCleanRoute}}">
+    <input type="hidden" name="routeId" value="{{routeId}}"/>
+    <button class="button button-warning cache-clean-btn" type="submit">{{&buttonText}}</button>
+</form>

package/admin/templates/fields/view/textarea.html

@@ -1 +1 @@
-<textarea name="{{&fieldName}}" id="{{&fieldName}}" disabled="disabled">{{&fieldValue}}</textarea>
+<textarea name="{{&fieldName}}" id="{{&fieldName}}" disabled="disabled">{{fieldValue}}</textarea>

package/bin/reldens-cms-generate-entities.js

@@ -7,7 +7,7 @@
  */
 
 const { Manager } = require('../index');
-const { Logger } = require('@reldens/utils');
+const { Logger, sc } = require('@reldens/utils');
 const { FileHandler } = require('@reldens/server-utils');
 const readline = require('readline');
 
@@ -18,22 +18,84 @@ class CmsEntitiesGenerator
     {
         this.args = process.argv.slice(2);
         this.projectRoot = process.cwd();
-        this.isOverride = this.args.includes('--override');
-        this.prismaClientPath = this.extractArgument('--prisma-client');
-        this.driver = this.extractArgument('--driver') || process.env.RELDENS_STORAGE_DRIVER || 'prisma';
+        this.config = {};
+        this.parseArguments();
     }
 
-    extractArgument(argumentName)
+    parseArguments()
     {
-        let argIndex = this.args.indexOf(argumentName);
-        if(-1 === argIndex || argIndex + 1 >= this.args.length){
-            return null;
+        for(let i = 0; i < this.args.length; i++){
+            let arg = this.args[i];
+            if(!arg.startsWith('--')){
+                continue;
+            }
+            let equalIndex = arg.indexOf('=');
+            if(-1 === equalIndex){
+                let flag = arg.substring(2);
+                if('override' === flag || 'dry-prisma' === flag || 'help' === flag || 'h' === flag){
+                    this.config[flag] = true;
+                }
+                continue;
+            }
+            let key = arg.substring(2, equalIndex);
+            let value = arg.substring(equalIndex + 1);
+            this.config[key] = value;
         }
-        return this.args[argIndex + 1];
+    }
+
+    shouldShowHelp()
+    {
+        return 0 === this.args.length || sc.get(this.config, 'help', false) || sc.get(this.config, 'h', false);
+    }
+
+    showHelp()
+    {
+        Logger.info('');
+        Logger.info('Reldens CMS Entities Generator');
+        Logger.info('==============================');
+        Logger.info('');
+        Logger.info('Usage: npx reldens-cms-generate-entities [options]');
+        Logger.info('');
+        Logger.info('Options:');
+        Logger.info('  --prisma-client=[path]           Path to Prisma client (e.g., ./prisma/client)');
+        Logger.info('  --driver=[driver]                Storage driver (default: prisma)');
+        Logger.info('  --override                       Force regeneration and overwrite existing files');
+        Logger.info('  --dry-prisma                     Skip Prisma schema generation');
+        Logger.info('  --help, -h                       Show this help message');
+        Logger.info('');
+        Logger.info('Examples:');
+        Logger.info('  npx reldens-cms-generate-entities --prisma-client=./prisma/client --driver=prisma');
+        Logger.info('  npx reldens-cms-generate-entities --override --dry-prisma');
+        Logger.info('  npx reldens-cms-generate-entities --help');
+        Logger.info('');
+    }
+
+    get isOverride()
+    {
+        return sc.get(this.config, 'override', false);
+    }
+
+    get isDryPrisma()
+    {
+        return sc.get(this.config, 'dry-prisma', false);
+    }
+
+    get prismaClientPath()
+    {
+        return sc.get(this.config, 'prisma-client', null);
+    }
+
+    get driver()
+    {
+        return sc.get(this.config, 'driver', process.env.RELDENS_STORAGE_DRIVER || 'prisma');
     }
 
     async run()
     {
+        if(this.shouldShowHelp()){
+            this.showHelp();
+            return true;
+        }
         if(this.isOverride){
             let confirmed = await this.confirmOverride();
             if(!confirmed){
@@ -41,6 +103,9 @@ class CmsEntitiesGenerator
                 return false;
             }
         }
+        if(this.isDryPrisma){
+            Logger.info('Running in dry-prisma mode - skipping Prisma schema generation.');
+        }
         let managerConfig = {projectRoot: this.projectRoot};
         if('prisma' === this.driver){
             let prismaClient = await this.loadPrismaClient();
@@ -55,7 +120,7 @@ class CmsEntitiesGenerator
         }
         Logger.debug('Reldens CMS Manager instance created for entities generation.');
         await manager.initializeDataServer();
-        let success = await manager.installer.generateEntities(manager.dataServer, this.isOverride, false);
+        let success = await manager.installer.generateEntities(manager.dataServer, this.isOverride, false, this.isDryPrisma);
         if(!success){
             Logger.error('Entities generation failed.');
             return false;
@@ -68,24 +133,26 @@ class CmsEntitiesGenerator
     {
         let clientPath = this.prismaClientPath;
         if(!clientPath){
-            clientPath = FileHandler.joinPaths(process.cwd(), 'generated-entities', 'prisma');
+            return false;
         }
-        if(!FileHandler.exists(clientPath)){
-            Logger.error('Prisma client not found at: '+clientPath);
-            Logger.error('Please ensure the client exists or specify a custom path with --prisma-client');
+        let resolvedPath = clientPath.startsWith('./') 
+            ? FileHandler.joinPaths(process.cwd(), clientPath.substring(2))
+            : clientPath;
+        if(!FileHandler.exists(resolvedPath)){
+            Logger.error('Prisma client not found at: '+resolvedPath);
             return false;
         }
         try {
-            let PrismaClientModule = require(clientPath);
+            let PrismaClientModule = require(resolvedPath);
             let PrismaClient = PrismaClientModule.PrismaClient || PrismaClientModule.default?.PrismaClient;
             if(!PrismaClient){
-                Logger.error('PrismaClient not found in module: '+clientPath);
+                Logger.error('PrismaClient not found in module: '+resolvedPath);
                 return false;
             }
-            Logger.debug('Prisma client loaded from: '+clientPath);
+            Logger.debug('Prisma client loaded from: '+resolvedPath);
             return new PrismaClient();
         } catch (error) {
-            Logger.error('Failed to load Prisma client from '+clientPath+': '+error.message);
+            Logger.error('Failed to load Prisma client from '+resolvedPath+': '+error.message);
             return false;
         }
     }

package/bin/reldens-cms.js

@@ -2,7 +2,7 @@
 
 /**
  *
- * Reldens - CMS - CLI Installer
+ * Reldens - CMS - CLI
  *
  */
 
@@ -21,10 +21,10 @@ if(FileHandler.exists(indexPath)){
 
 let managerConfig = {projectRoot};
 let entitiesPath = FileHandler.joinPaths(
-    projectRoot, 
-    'generated-entities', 
-    'models', 
-    'prisma', 
+    projectRoot,
+    'generated-entities',
+    'models',
+    'prisma',
     'registered-models-prisma.js'
 );
 
@@ -48,4 +48,4 @@ manager.start().then((result) => {
 }).catch((error) => {
     Logger.critical('Failed to start CMS:', error);
     process.exit();
-});
+});

package/lib/admin-manager/contents-builder.js

@@ -0,0 +1,256 @@
+/**
+ *
+ * Reldens - ContentsBuilder
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class ContentsBuilder
+{
+
+    constructor(props)
+    {
+        this.renderCallback = props.renderCallback;
+        this.adminFilesContents = props.adminFilesContents;
+        this.stylesFilePath = props.stylesFilePath;
+        this.scriptsFilePath = props.scriptsFilePath;
+        this.rootPath = props.rootPath;
+        this.branding = props.branding;
+        this.translations = props.translations;
+        this.resources = props.resources;
+        this.buildAdminCssOnActivation = props.buildAdminCssOnActivation;
+        this.buildAdminScriptsOnActivation = props.buildAdminScriptsOnActivation;
+        this.updateAdminAssetsDistOnActivation = props.updateAdminAssetsDistOnActivation;
+        this.emitEvent = props.emitEvent;
+        this.editPath = props.editPath;
+        this.savePath = props.savePath;
+        this.deletePath = props.deletePath;
+        this.fetchUploadProperties = props.fetchUploadProperties;
+        this.fetchTranslation = props.fetchTranslation;
+        this.fetchEntityIdPropertyKey = props.fetchEntityIdPropertyKey;
+        this.adminContents = {};
+    }
+
+    async buildAdminContents()
+    {
+        this.adminContents.layout = await this.buildLayout();
+        this.adminContents.sideBar = await this.buildSideBar();
+        this.adminContents.login = await this.renderRoute(this.adminFilesContents.login, '');
+        this.adminContents.dashboard = await this.renderRoute(this.adminFilesContents.dashboard, this.adminContents.sideBar);
+        this.adminContents.entities = await this.buildEntitiesContents();
+        await this.emitEvent('reldens.buildAdminContentsAfter');
+        return this.adminContents;
+    }
+
+    async buildLayout()
+    {
+        return await this.render(
+            this.adminFilesContents.layout,
+            {
+                sideBar: '{{&sideBar}}',
+                pageContent: '{{&pageContent}}',
+                stylesFilePath: this.stylesFilePath,
+                scriptsFilePath: this.scriptsFilePath,
+                rootPath: this.rootPath,
+                brandingCompanyName: this.branding.companyName,
+                copyRight: this.branding.copyRight
+            }
+        );
+    }
+
+    async buildSideBar()
+    {
+        let navigationContents = {};
+        let eventBuildSideBarBefore = {navigationContents};
+        await this.emitEvent('reldens.eventBuildSideBarBefore', eventBuildSideBarBefore);
+        navigationContents = eventBuildSideBarBefore.navigationContents;
+        for(let driverResource of this.resources()){
+            let navigation = driverResource.options?.navigation;
+            let name = this.translations.labels[driverResource.id()] || this.translations.labels[driverResource.entityKey];
+            let path = this.rootPath+'/'+(driverResource.id().replace(/_/g, '-'));
+            if(navigation?.name){
+                if(!navigationContents[navigation.name]){
+                    navigationContents[navigation.name] = {};
+                }
+                navigationContents[navigation.name][driverResource.id()] = await this.render(
+                    this.adminFilesContents.sideBarItem,
+                    {name, path}
+                );
+                continue;
+            }
+            navigationContents[driverResource.id()] = await this.render(
+                this.adminFilesContents.sideBarItem,
+                {name, path}
+            );
+        }
+        let eventAdminSideBarBeforeSubItems = {navigationContents};
+        await this.emitEvent('reldens.adminSideBarBeforeSubItems', eventAdminSideBarBeforeSubItems);
+        let navigationView = '';
+        for(let id of Object.keys(navigationContents)){
+            if(sc.isObject(navigationContents[id])){
+                let subItems = '';
+                for(let subId of Object.keys(navigationContents[id])){
+                    subItems += navigationContents[id][subId];
+                }
+                navigationView += await this.render(
+                    this.adminFilesContents.sideBarHeader,
+                    {name: id, subItems}
+                );
+                continue;
+            }
+            navigationView += navigationContents[id];
+        }
+        let eventAdminSideBarBeforeRender = {navigationContents, navigationView};
+        await this.emitEvent('reldens.adminSideBarBeforeRender', eventAdminSideBarBeforeRender);
+        return await this.render(
+            this.adminFilesContents.sideBar,
+            {
+                rootPath: this.rootPath,
+                navigationView: eventAdminSideBarBeforeRender.navigationView
+            }
+        );
+    }
+
+    async buildEntitiesContents()
+    {
+        let entitiesContents = {};
+        for(let driverResource of this.resources()){
+            let templateTitle = this.translations.labels[driverResource.id()];
+            let entityName = (driverResource.id().replace(/_/g, '-'));
+            let entityListRoute = this.rootPath+'/'+entityName;
+            let entityEditRoute = entityListRoute+this.editPath;
+            let entitySaveRoute = entityListRoute+this.savePath;
+            let entityDeleteRoute = entityListRoute+this.deletePath;
+            let uploadProperties = this.fetchUploadProperties(driverResource);
+            let multipartFormData = 0 < Object.keys(uploadProperties).length ? ' enctype="multipart/form-data"' : '';
+            let idProperty = this.fetchEntityIdPropertyKey(driverResource);
+            let editProperties = Object.keys(driverResource.options.properties);
+            editProperties.splice(editProperties.indexOf(idProperty), 1);
+            let filters = driverResource.options.filterProperties.map((property) => {
+                return {
+                    propertyKey: property,
+                    name: this.fetchTranslation(property),
+                    value: '{{&'+property+'}}'
+                };
+            });
+            let fields = driverResource.options.showProperties.map((property) => {
+                return {
+                    name: this.fetchTranslation(property),
+                    value: '{{&'+property+'}}'
+                };
+            });
+            let editFields = editProperties.map((property) => {
+                return {
+                    name: this.fetchTranslation(property),
+                    value: '{{&'+property+'}}'
+                };
+            });
+            let sectionsContents = this.adminFilesContents?.sections;
+            let extraContentForList = sc.get(sectionsContents?.list, driverResource.entityPath, '');
+            let extraContentForView = await this.render(
+                sc.get(sectionsContents?.view, driverResource.entityPath, ''),
+                {
+                    id: '{{&id}}',
+                    entitySerializedData: '{{&entitySerializedData}}'
+                }
+            );
+            let extraFormContentForView = sc.get(sectionsContents?.viewForm, driverResource.entityPath, '');
+            let extraContentForEdit = sc.get(sectionsContents?.edit, driverResource.entityPath, '');
+            let extraFormContentForEdit = sc.get(sectionsContents?.editForm, driverResource.entityPath, '');
+            entitiesContents[entityName] = {
+                list: await this.render(
+                    this.adminFilesContents.list,
+                    {
+                        entityName,
+                        templateTitle,
+                        entityListRoute,
+                        entityEditRoute,
+                        filters,
+                        list: '{{&list}}',
+                        pagination: '{{&pagination}}',
+                        extraContent: '{{&extraContentForList}}'+extraContentForList,
+                    }
+                ),
+                view: await this.render(
+                    this.adminFilesContents.view,
+                    {
+                        entityName,
+                        templateTitle,
+                        entityDeleteRoute,
+                        entityListRoute,
+                        fields,
+                        id: '{{&id}}',
+                        entityEditRoute: '{{&entityEditRoute}}',
+                        entityNewRoute: '{{&entityNewRoute}}',
+                        extraContent: '{{&extraContentForView}}'+extraContentForView,
+                        extraFormContent: '{{&extraFormContentForView}}'+extraFormContentForView
+                    }
+                ),
+                edit: await this.render(
+                    this.adminFilesContents.edit,
+                    {
+                        entityName,
+                        entitySaveRoute,
+                        multipartFormData,
+                        editFields,
+                        idValue: '{{&idValue}}',
+                        idProperty: '{{&idProperty}}',
+                        templateTitle: '{{&templateTitle}}',
+                        entityViewRoute: '{{&entityViewRoute}}',
+                        extraContent: '{{&extraContentForEdit}}'+extraContentForEdit,
+                        extraFormContent: '{{&extraFormContentForEdit}}'+extraFormContentForEdit
+                    }
+                )
+            };
+        }
+        return entitiesContents;
+    }
+
+    async render(content, params)
+    {
+        return await this.renderCallback(content, params);
+    }
+
+    async renderRoute(pageContent, sideBar)
+    {
+        return await this.render(
+            this.adminContents.layout,
+            {
+                stylesFilePath: this.stylesFilePath,
+                scriptsFilePath: this.scriptsFilePath,
+                brandingCompanyName: this.branding.companyName,
+                copyRight: this.branding.copyRight,
+                pageContent,
+                sideBar
+            }
+        );
+    }
+
+    async buildAdminScripts()
+    {
+        if(!sc.isFunction(this.buildAdminScriptsOnActivation)){
+            return false;
+        }
+        return this.buildAdminScriptsOnActivation();
+    }
+
+    async updateAdminAssets()
+    {
+        if(!sc.isFunction(this.updateAdminAssetsDistOnActivation)){
+            return false;
+        }
+        return this.updateAdminAssetsDistOnActivation();
+    }
+
+    async buildAdminCss()
+    {
+        if(!sc.isFunction(this.buildAdminCssOnActivation)){
+            return false;
+        }
+        return this.buildAdminCssOnActivation();
+    }
+
+}
+
+module.exports.ContentsBuilder = ContentsBuilder;