@reldens/cms 0.49.0 → 0.50.0

package/.claude/advanced-usage-guide.md

@@ -96,3 +96,278 @@ cms.events.on('adminEntityExtraData', ({entitySerializedData, entity}) => {
     entitySerializedData.customField = 'Custom Value';
 });
 ```
+
+## Event-Driven Customizations
+
+The CMS uses an event system for extensibility. This allows you to add custom behavior without modifying core CMS files.
+
+### Admin UI Customizations
+
+Add buttons and content to admin views using events. Always use templates and renderCallback - never hardcode HTML in classes.
+
+**Step 1: Create template file** (`admin/templates/custom-button.html`):
+```html
+<button class="button button-primary" type="submit" form="edit-form"
+        name="customAction" value="customValue">
+    {{&buttonText}}
+</button>
+```
+
+**Step 2: Register template** in `lib/templates-list.js`:
+```javascript
+module.exports.TemplatesList = {
+    // ... existing templates
+    customButton: 'custom-button.html',
+};
+```
+
+**Step 3: Create subscriber class**:
+```javascript
+const { Logger, sc } = require('@reldens/utils');
+
+class CustomButtonSubscriber
+{
+
+    constructor(props)
+    {
+        this.events = sc.get(props, 'events', false);
+        this.renderCallback = sc.get(props, 'renderCallback', false);
+        this.customButtonTemplate = sc.get(props, 'customButtonTemplate', '');
+        this.translations = sc.get(props, 'translations', {});
+        this.setupEvents();
+    }
+
+    setupEvents()
+    {
+        if(!this.events){
+            Logger.error('Events Manager not found on CustomButtonSubscriber.');
+            return false;
+        }
+        this.events.on('reldens.adminEditPropertiesPopulation', this.addCustomButton.bind(this));
+    }
+
+    async addCustomButton(event)
+    {
+        if(!this.customButtonTemplate){
+            Logger.error('Custom button template not found');
+            return '';
+        }
+        if(!this.renderCallback){
+            Logger.error('Render callback not available');
+            return '';
+        }
+        if(!event.renderedEditProperties.extraContentForEdit){
+            event.renderedEditProperties.extraContentForEdit = '';
+        }
+        let buttonHtml = await this.renderCallback(
+            this.customButtonTemplate,
+            {
+                buttonText: sc.get(this.translations.labels, 'customAction', 'Custom Action')
+            }
+        );
+        event.renderedEditProperties.extraContentForEdit += buttonHtml;
+    }
+
+}
+```
+
+**Step 4: Initialize in AdminManager**:
+```javascript
+this.customButtonSubscriber = new CustomButtonSubscriber({
+    events: this.events,
+    renderCallback: this.renderCallback,
+    customButtonTemplate: this.adminFilesContents.customButton,
+    translations: this.translations
+});
+```
+
+**See `lib/cache/save-and-clear-cache-subscriber.js` for complete working example.**
+
+### Form Processing Customizations
+
+Handle custom save actions and form submissions:
+
+```javascript
+class CustomFormHandler
+{
+
+    constructor(props)
+    {
+        this.events = props.events;
+        this.dataServer = props.dataServer;
+        this.setupEvents();
+    }
+
+    setupEvents()
+    {
+        this.events.on('reldens.dynamicFormRequestHandler.beforeSave', this.beforeSave.bind(this));
+        this.events.on('reldens.dynamicFormRequestHandler.afterSave', this.afterSave.bind(this));
+    }
+
+    async beforeSave(event)
+    {
+        if(event.validationResult.errors){
+            event.validationResult.extraErrors = this.customValidation(event.formData);
+        }
+    }
+
+    async afterSave(event)
+    {
+        let customAction = event.req?.body?.customAction;
+        if('customValue' === customAction){
+            await this.performCustomAction(event.result);
+        }
+    }
+
+    customValidation(formData)
+    {
+        let errors = [];
+        if(formData.customField && formData.customField.length < 10){
+            errors.push('customField must be at least 10 characters');
+        }
+        return errors;
+    }
+
+    async performCustomAction(savedEntity)
+    {
+        Logger.info('Performing custom action for entity:', savedEntity.id);
+    }
+
+}
+
+let manager = new Manager(managerConfiguration);
+new CustomFormHandler({
+    events: manager.events,
+    dataServer: manager.dataServer
+});
+```
+
+### Entity Config Overrides
+
+Customize generated entity configurations without editing generated files:
+
+```javascript
+class CmsPagesOverride
+{
+
+    /**
+     * @param {Object} baseConfig
+     * @param {Object} props
+     * @returns {Object}
+     */
+    static propertiesConfig(baseConfig, props)
+    {
+        baseConfig.properties.meta_og_image = {
+            ...baseConfig.properties.meta_og_image,
+            isUpload: true,
+            allowedTypes: ['image/jpeg', 'image/png', 'image/webp'],
+            bucket: 'cms-og-images',
+            bucketPath: '/og-images/'
+        };
+        baseConfig.properties.status = {
+            ...baseConfig.properties.status,
+            type: 'select',
+            options: [
+                { value: 'draft', label: 'Draft' },
+                { value: 'published', label: 'Published' },
+                { value: 'archived', label: 'Archived' }
+            ]
+        };
+        return baseConfig;
+    }
+
+}
+
+let manager = new Manager({
+    ...managerConfiguration,
+    entitiesConfigOverride: {
+        'cmsPages': CmsPagesOverride  // CRITICAL: Use camelCase key from entities-config.js
+    }
+});
+```
+
+**CRITICAL: Entity keys must match exactly as defined in `generated-entities/entities-config.js`:**
+- Use `'cmsPages'` NOT `'cms-pages'`
+- Use `'cmsBlocks'` NOT `'cms-blocks'`
+- Use `'cmsForms'` NOT `'cms-forms'`
+- Keys are camelCase, not kebab-case
+
+### Conditional Event Handling
+
+Control when customizations apply based on conditions:
+
+```javascript
+const { Logger, sc } = require('@reldens/utils');
+
+class ConditionalCustomization
+{
+
+    constructor(props)
+    {
+        this.events = sc.get(props, 'events', false);
+        this.cacheManager = sc.get(props, 'cacheManager', false);
+        this.renderCallback = sc.get(props, 'renderCallback', false);
+        this.contentTemplate = sc.get(props, 'contentTemplate', '');
+        this.setupEvents();
+    }
+
+    setupEvents()
+    {
+        if(!this.cacheManager?.isEnabled()){
+            return false;
+        }
+        if(!this.events){
+            Logger.error('Events Manager not found.');
+            return false;
+        }
+        this.events.on('reldens.adminEditPropertiesPopulation', this.addContent.bind(this));
+    }
+
+    async addContent(event)
+    {
+        if('routes' !== event.driverResource.id()){
+            return false;
+        }
+        if(!this.contentTemplate || !this.renderCallback){
+            return false;
+        }
+        if(!event.renderedEditProperties.extraContentForEdit){
+            event.renderedEditProperties.extraContentForEdit = '';
+        }
+        let contentHtml = await this.renderCallback(this.contentTemplate, {});
+        event.renderedEditProperties.extraContentForEdit += contentHtml;
+    }
+
+}
+
+let manager = new Manager(managerConfiguration);
+new ConditionalCustomization({
+    events: manager.events,
+    cacheManager: manager.cacheManager,
+    renderCallback: manager.renderCallback,
+    contentTemplate: manager.adminFilesContents.conditionalContent
+});
+```
+
+**CRITICAL: Never hardcode HTML strings in subscriber classes. Always use templates with renderCallback and translations.**
+
+### Available Admin Events
+
+**View/Edit/List Property Population**:
+- `reldens.adminViewPropertiesPopulation` - Add content to view pages
+- `reldens.adminEditPropertiesPopulation` - Add content to edit pages
+- `reldens.adminListPropertiesPopulation` - Add content to list pages
+
+**Entity Operations**:
+- `reldens.adminBeforeEntitySave` - Before entity save
+- `reldens.adminAfterEntitySave` - After entity save
+
+**Form Processing**:
+- `reldens.dynamicFormRequestHandler.beforeValidation` - Before form validation
+- `reldens.dynamicFormRequestHandler.beforeSave` - Before form save
+- `reldens.dynamicFormRequestHandler.afterSave` - After form save
+
+**Setup Events**:
+- `reldens.setupAdminRouter` - Setup admin router
+- `reldens.setupAdminRoutes` - Setup admin routes
+- `reldens.setupAdminManagers` - Setup admin managers

package/CLAUDE.md

@@ -521,10 +521,16 @@ The CMS provides extensive event hooks for customization:
 - `reldens.setupAdminRoutes` - After route setup
 - `reldens.setupAdminManagers` - After manager setup
 - `reldens.adminBeforeEntitySave` - Before entity save (used by password encryption handler)
+- `reldens.adminAfterEntitySave` - After entity save
+- `reldens.adminViewPropertiesPopulation` - Add content to view pages
+- `reldens.adminEditPropertiesPopulation` - Add content to edit pages
+- `reldens.adminListPropertiesPopulation` - Add content to list pages
 
 ### Template Reloading Events
 - `reldens.templateReloader.templatesChanged` - Templates changed
 
+See `.claude/advanced-usage-guide.md` for comprehensive event-driven customization patterns and examples.
+
 ## Development Workflow
 
 ### Template Reloading
@@ -569,6 +575,67 @@ Define custom entity configurations in `entitiesConfig`:
 }
 ```
 
+### Entity Config Overrides
+Override generated entity configurations without editing generated files using `entitiesConfigOverride`:
+```javascript
+class CmsPagesOverride
+{
+
+    /**
+     * @param {Object} baseConfig
+     * @param {Object} props
+     * @returns {Object}
+     */
+    static propertiesConfig(baseConfig, props)
+    {
+        baseConfig.properties.meta_og_image = {
+            dbType: 'varchar',
+            isUpload: true,
+            allowedTypes: 'image',
+            bucket: 'public/assets/media',
+            bucketPath: '/assets/media/'
+        };
+        return baseConfig;
+    }
+
+}
+
+const manager = new Manager({
+    entitiesConfigOverride: {
+        'cmsPages': CmsPagesOverride  // Use camelCase key from entities-config.js
+    }
+});
+```
+
+**CRITICAL: Entity keys must match exactly as defined in `generated-entities/entities-config.js`**
+- Use camelCase: `'cmsPages'`, `'cmsBlocks'`, `'cmsForms'`
+- NOT kebab-case: `'cms-pages'`, `'cms-blocks'`, `'cms-forms'`
+
+Supports three override patterns:
+- **Class-based**: Class with static `propertiesConfig(baseConfig, props)` method
+- **Function-based**: Function that receives `(baseConfig, props)` and returns modified config
+- **Object-based**: Plain object that gets deep merged with base config
+
+**Upload Field Configuration:**
+- `allowedTypes`: Must be a STRING ('image', 'audio', 'text'), NOT an array
+- `bucket`: Relative path from projectRoot (e.g., 'public/assets/media')
+- `bucketPath`: URL path for display (e.g., '/assets/media/')
+- Do NOT use spread syntax - replace entire property object
+- Do NOT use FileHandler.joinPaths() - bucket paths are relative to projectRoot
+
+**Upload Field Removal:**
+- Admin edit pages automatically show an "X" button before uploaded filenames
+- Clicking X creates hidden input `clear_fieldname=1` in form
+- Server detects this and sets field to null in database
+- File remains on disk - only database field is cleared
+- Template: `admin/templates/fields/edit/file-claude.html`
+- Client JS: `admin/reldens-admin-client-claude.js` (remove upload functionality)
+- Server handling: `lib/admin-manager/router-contents-claude.js` (clear_ parameter detection)
+
+**Example subscribers**: See `lib/cache/add-cache-button-subscriber.js` and `lib/cache/save-and-clear-cache-subscriber.js` for complete working examples of event-driven UI customizations.
+
+See `.claude/advanced-usage-guide.md` for detailed examples.
+
 ## Security Features
 
 - **Authentication** - Role-based admin access

package/admin/reldens-admin-client.css

@@ -25,7 +25,7 @@
     background-color: var(--lightGrey);
     margin: 0;
     padding: 0;
-    font-size: 12px;
+    font-size: 0.75rem;
 
     .wrapper {
         display: flex;
@@ -40,7 +40,7 @@
         right: 0;
         padding: 1rem 5rem 1rem 2rem;
         border-radius: 8px 0 0 8px;
-        font-size: 14px;
+        font-size: 0.875rem;
 
         &.success, &.error {
             display: block;
@@ -91,7 +91,7 @@
         padding: 0.5rem 1rem;
         border: none;
         border-radius: 4px;
-        font-size: 14px;
+        font-size: 0.875rem;
         cursor: pointer;
         text-decoration: none;
 
@@ -211,7 +211,7 @@
                 color: var(--lightGrey);
                 text-decoration: none;
                 border-left: 3px solid transparent;
-                font-size: 12px;
+                font-size: 0.75rem;
                 border-left: 3px solid #0000;
                 padding: 0.1rem 0.1rem 0.1rem 1rem;
                 margin-top: 0.3rem;
@@ -242,7 +242,7 @@
             color: var(--lightGrey);
             text-decoration: none;
             cursor: pointer;
-            font-size: 14px;
+            font-size: 0.875rem;
             font-weight: var(--font-semi-bold);
             border-bottom: 1px solid var(--darkBlue);
 
@@ -274,6 +274,10 @@
             justify-content: end;
             margin-bottom: 1rem;
         }
+
+        .extra-actions {
+            justify-content: end;
+        }
     }
 
     .forms-container {
@@ -283,7 +287,7 @@
     }
 
     .form-title {
-        font-size: 22px;
+        font-size: 1.375rem;
         margin-bottom: 2%;
         color: var(--darkGrey);
         text-align: center;
@@ -329,7 +333,7 @@
     }
 
     & h2 {
-        font-size: 22px;
+        font-size: 1.375rem;
         margin: 0 0 2rem;
         color: var(--darkGrey);
         text-align: center;
@@ -533,7 +537,7 @@
                 vertical-align: middle;
                 align-items: center;
                 margin: 0 1rem 1rem 0;
-                font-size: 14px;
+                font-size: 0.875rem;
                 color: var(--darkGrey);
 
                 &.filters-toggle {
@@ -650,7 +654,7 @@
 
     .entity-view, .entity-edit {
         & h2 {
-            font-size: 22px;
+            font-size: 1.375rem;
             margin-bottom: 2rem;
             color: var(--darkGrey);
             text-align: center;
@@ -691,6 +695,10 @@
                         margin-left: 0.5rem;
                         margin-top: 0.5rem;
                     }
+
+                    .remove-upload-btn {
+                        cursor: pointer;
+                    }
                 }
             }
         }
@@ -757,7 +765,7 @@
     .extra-actions {
         display: flex;
         width: 100%;
-        justify-content: end;
+        justify-content: center;
         margin: 1rem 0;
     }
 
@@ -804,7 +812,7 @@
 
     .dialog-content h5 {
         margin: 0 0 1rem 0;
-        font-size: 18px;
+        font-size: 1.125rem;
         color: var(--darkGrey);
     }
 

package/admin/reldens-admin-client.js

@@ -242,6 +242,9 @@ window.addEventListener('DOMContentLoaded', () => {
                 ? 'Success!'
                 : 'There was an error: '+escapeHTML(errorMessages[result] || result);
             deleteCookie('result');
+            queryParams.delete('result');
+            let newUrl = location.pathname + (queryParams.toString() ? '?' + queryParams.toString() : '');
+            window.history.replaceState({}, '', newUrl);
         }
     }
 
@@ -282,4 +285,35 @@ window.addEventListener('DOMContentLoaded', () => {
         });
     }
 
+    // remove upload button functionality:
+    let removeUploadButtons = document.querySelectorAll('.remove-upload-btn');
+    if(removeUploadButtons){
+        for(let button of removeUploadButtons){
+            button.addEventListener('click', (event) => {
+                event.preventDefault();
+                let fieldName = button.getAttribute('data-field');
+                let fileInput = document.getElementById(fieldName);
+                let currentFileDisplay = document.querySelector('.upload-current-file[data-field="'+fieldName+'"]');
+                if(currentFileDisplay){
+                    currentFileDisplay.style.display = 'none';
+                }
+                if(fileInput){
+                    fileInput.value = '';
+                    let form = fileInput.closest('form');
+                    if(form){
+                        let clearFieldName = 'clear_'+fieldName;
+                        let existingClearInput = form.querySelector('input[name="'+clearFieldName+'"]');
+                        if(!existingClearInput){
+                            let clearInput = document.createElement('input');
+                            clearInput.type = 'hidden';
+                            clearInput.name = clearFieldName;
+                            clearInput.value = '1';
+                            form.appendChild(clearInput);
+                        }
+                    }
+                }
+            });
+        }
+    }
+
 });

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

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

package/admin/templates/edit.html

@@ -6,6 +6,9 @@
         <button class="button button-primary button-submit" type="submit" form="edit-form" name="saveAction" value="saveAndGoBack">Save and go back</button>
         <a class="button button-secondary button-back" href="{{&entityViewRoute}}">Cancel</a>
     </div>
+    <div class="extra-actions">
+        {{&extraContent}}
+    </div>
     <form name="edit-form" id="edit-form" action="{{&entitySaveRoute}}" method="post"{{&multipartFormData}}>
         <input type="hidden" name="{{&idProperty}}" value="{{&idValue}}"/>
         <div class="edit-field">

package/admin/templates/fields/edit/file.html

@@ -1,2 +1,2 @@
-<p>{{&fieldValue}}</p>
+{{#fieldValue}}<p class="upload-current-file" data-field="{{&fieldName}}"><button type="button" class="remove-upload-btn" data-field="{{&fieldName}}" title="REMOVE">X</button> - {{&fieldValue}}</p>{{/fieldValue}}
 <input type="file" name="{{&fieldName}}" id="{{&fieldName}}"{{&required}}{{&fieldDisabled}}{{&multiple}}/>

package/admin/templates/view.html

@@ -4,13 +4,16 @@
         <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-top-{{&id}}" id="delete-form-top-{{&id}}" action="{{&entityDeleteRoute}}" method="post">
+        <form class="form-delete" name="delete-form-top-{{&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>
+    <div class="extra-actions">
+        {{&extraContent}}
+    </div>
     {{#fields}}
     <div class="view-field">
         <span class="field-name">{{&name}}</span>
@@ -22,7 +25,7 @@
         <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">
+        <form class="form-delete" name="delete-form-{{&id}}" action="{{&entityDeleteRoute}}" method="post">
             <span>
                 <input type="hidden" name="ids[]" value="{{&id}}"/>
                 <button class="button button-danger" type="submit">Delete</button>

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

@@ -473,6 +473,8 @@ class RouterContents
             if(!shouldProcess){
                 continue;
             }
+            let clearFieldParam = sc.get(req.body, 'clear_'+i, false);
+            let isExplicitClear = '1' === clearFieldParam;
             let propertyUpdateValue = sc.get(req.body, i, null);
             if('null' === propertyUpdateValue){
                 propertyUpdateValue = null;
@@ -480,7 +482,12 @@ class RouterContents
             let propertyType = sc.get(property, 'type', 'string');
             if(property.isUpload){
                 propertyType = 'upload';
-                propertyUpdateValue = this.prepareUploadPatchData(req, i, propertyUpdateValue, property);
+                if(isExplicitClear){
+                    propertyUpdateValue = null;
+                }
+                if(!isExplicitClear){
+                    propertyUpdateValue = this.prepareUploadPatchData(req, i, propertyUpdateValue, property);
+                }
             }
             if('boolean' === propertyType){
                 propertyUpdateValue = '1' === propertyUpdateValue || 'on' === propertyUpdateValue;
@@ -518,7 +525,7 @@ class RouterContents
                     continue;
                 }
             }
-            if(!property.isUpload || (property.isUpload && !isNull)){
+            if(!property.isUpload || (property.isUpload && (!isNull || isExplicitClear))){
                 entityDataPatch[i] = propertyUpdateValue;
             }
         }
@@ -546,13 +553,13 @@ class RouterContents
             if(resourceProperty.isArray){
                 fieldValue = fieldValue.split(resourceProperty.isArray).map((value) => {
                     let target = resourceProperty.isUpload ? ' target="_blank"' : '';
-                    let fieldValuePart = resourceProperty.isUpload && resourceProperty.bucketPath
+                    let fieldValuePart = resourceProperty.isUpload && resourceProperty.bucketPath && value
                         ? resourceProperty.bucketPath+value
                         : value;
                     return {fieldValuePart, fieldOriginalValuePart: value, target};
                 });
             }
-            if(!resourceProperty.isArray && resourceProperty.isUpload){
+            if(!resourceProperty.isArray && resourceProperty.isUpload && fieldValue){
                 fieldValue = resourceProperty.bucketPath+fieldValue;
             }
         }

package/lib/cache/add-cache-button-subscriber.js

@@ -87,7 +87,8 @@ class AddCacheButtonSubscriber
 
     async generateCacheCleanButton(event)
     {
-        if('routes' !== event.driverResource.id()){
+        let entityId = event.driverResource.id();
+        if('routes' !== entityId && 'cms_pages' !== entityId){
             return false;
         }
         if(!event.loadedEntity){
@@ -98,6 +99,13 @@ class AddCacheButtonSubscriber
             Logger.error('Missing loaded entity ID on AddCacheButtonSubscriber.');
             return false;
         }
+        let routeId = event.loadedEntity.id;
+        if('cms_pages' === entityId){
+            if(!event.loadedEntity.route_id){
+                return false;
+            }
+            routeId = event.loadedEntity.route_id;
+        }
         if(!this.cacheCleanButton){
             Logger.error('Cache clean button template content not found');
             return '';
@@ -106,11 +114,13 @@ class AddCacheButtonSubscriber
             Logger.error('Render callback not available for cache button');
             return '';
         }
+        let refererUrl = sc.get(event.req, 'originalUrl', '');
         return await this.renderCallback(
             this.cacheCleanButton,
             {
                 cacheCleanRoute: this.cacheCleanRoute,
-                routeId: event.loadedEntity.id,
+                routeId: routeId,
+                refererUrl: refererUrl,
                 buttonText: sc.get(this.translations.labels, 'cleanCache', 'cleanCache')
             }
         );
@@ -135,7 +145,11 @@ class AddCacheButtonSubscriber
                 buttonText: sc.get(this.translations.labels, 'clearAllCache', 'clearAllCache'),
                 clearAllCacheRoute: this.clearAllCacheRoute,
                 confirmTitle: sc.get(this.translations.labels, 'confirmClearCache', 'confirmClearCache'),
-                confirmMessage: sc.get(this.translations.messages, 'confirmClearCacheMessage', 'confirmClearCacheMessage'),
+                confirmMessage: sc.get(
+                    this.translations.messages,
+                    'confirmClearCacheMessage',
+                    'confirmClearCacheMessage'
+                ),
                 warningText: sc.get(this.translations.labels, 'warning', 'warning'),
                 warningMessage: sc.get(this.translations.messages, 'clearCacheWarning', 'clearCacheWarning'),
                 cancelText: sc.get(this.translations.labels, 'cancel', 'cancel'),

package/lib/cache/cache-manager.js

@@ -15,6 +15,21 @@ class CacheManager
         this.projectRoot = sc.get(props, 'projectRoot', './');
         this.cacheBasePath = FileHandler.joinPaths(this.projectRoot, '.reldens_cms_cache');
         this.enabled = sc.get(props, 'enabled', true);
+        this.domainMapping = sc.get(props, 'domainMapping', {});
+        this.reverseDomainMapping = this.buildReverseDomainMapping();
+    }
+
+    buildReverseDomainMapping()
+    {
+        let reverse = {};
+        for(let domain in this.domainMapping){
+            let canonical = this.domainMapping[domain];
+            if(!reverse[canonical]){
+                reverse[canonical] = [];
+            }
+            reverse[canonical].push(domain);
+        }
+        return reverse;
     }
 
     generateCacheKey(domain, path)
@@ -93,22 +108,22 @@ class CacheManager
 
     async delete(domain, path)
     {
-        let cacheByDomains = this.fetchCachePathsByDomain(domain, path);
-        for(let cacheInfo of cacheByDomains){
-            let allCacheFiles = this.findAllCacheFilesForPath(cacheInfo.domain || domain, path);
+        let cacheByDomains = this.resolveCacheDomains(domain);
+        if(0 === cacheByDomains.length){
+            return true;
+        }
+        for(let domainInfo of cacheByDomains){
+            let actualDomain = domainInfo.domain;
+            let allCacheFiles = this.findAllCacheFilesForPath(actualDomain, path);
             if(0 === allCacheFiles.length){
-                let singleCacheInfo = this.generateCacheKey(cacheInfo.domain || domain, path);
+                let singleCacheInfo = this.generateCacheKey(actualDomain, path);
                 if(!FileHandler.exists(singleCacheInfo.fullPath)){
-                    Logger.debug('No cache files found for: '+path);
+                    //Logger.debug('No cache files found for: '+path+' in domain: '+actualDomain);
                     continue;
                 }
                 allCacheFiles = [singleCacheInfo.fullPath];
             }
             for(let cacheFilePath of allCacheFiles){
-                if(!FileHandler.exists(cacheFilePath)){
-                    Logger.debug('File does not exist: '+cacheFilePath);
-                    continue;
-                }
                 if(!FileHandler.remove(cacheFilePath)){
                     Logger.error('Failed to delete cache file: '+cacheFilePath);
                     return false;
@@ -119,19 +134,22 @@ class CacheManager
         return true;
     }
 
-    fetchCachePathsByDomain(domain, path)
+    resolveCacheDomains(domain)
     {
         let cacheByDomains = [];
-        if(domain && 'default' !== domain){
-            cacheByDomains.push({domain: domain});
-            return cacheByDomains;
-        }
-        if(!FileHandler.exists(this.cacheBasePath)){
+        if(!domain || 'default' === domain){
+            if(!FileHandler.exists(this.cacheBasePath)){
+                return cacheByDomains;
+            }
+            let cachedDomainFolders = FileHandler.readFolder(this.cacheBasePath);
+            for(let cachedDomainFolder of cachedDomainFolders) {
+                cacheByDomains.push({domain: cachedDomainFolder});
+            }
             return cacheByDomains;
         }
-        let cachedDomainFolders = FileHandler.readFolder(this.cacheBasePath);
-        for(let cachedDomainFolder of cachedDomainFolders) {
-            cacheByDomains.push({domain: cachedDomainFolder});
+        let domainsToDelete = this.reverseDomainMapping[domain] || [domain];
+        for(let mappedDomain of domainsToDelete){
+            cacheByDomains.push({domain: mappedDomain});
         }
         return cacheByDomains;
     }

package/lib/cache/cache-routes-handler.js

@@ -77,7 +77,10 @@ class CacheRoutesHandler
         if(!cleanResult){
             return res.json({error: 'Failed to clean cache'});
         }
-        return res.redirect(this.rootPath+'/routes/view'+'?id='+routeId+'&result=success');
+        let defaultRedirect = this.rootPath+'/routes/view?id='+routeId;
+        let refererUrl = sc.get(req.body, 'refererUrl', defaultRedirect);
+        let redirectUrl = refererUrl+(refererUrl.includes('?') ? '&' : '?')+'result=success';
+        return res.redirect(redirectUrl);
     }
 
     async processClearAllCache(req, res)

package/lib/entities-config-processor.js

@@ -0,0 +1,59 @@
+/**
+ *
+ * Reldens - EntitiesConfigProcessor
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class EntitiesConfigProcessor
+{
+
+    /**
+     * @param {Object} baseEntitiesConfig
+     * @param {Object} overrides
+     * @param {Object} props
+     * @returns {Object}
+     */
+    static applyOverrides(baseEntitiesConfig, overrides, props = {})
+    {
+        if(!overrides || 'object' !== typeof overrides || 0 === Object.keys(overrides).length){
+            return baseEntitiesConfig;
+        }
+        let mergedConfig = sc.deepMergeProperties({}, baseEntitiesConfig);
+        for(let entityKey of Object.keys(overrides)){
+            let override = overrides[entityKey];
+            if(!override){
+                continue;
+            }
+            let baseConfig = mergedConfig[entityKey] || {};
+            mergedConfig[entityKey] = this.applyEntityOverride(entityKey, baseConfig, override, props);
+        }
+        return mergedConfig;
+    }
+
+    /**
+     * @param {string} entityKey
+     * @param {Object} baseConfig
+     * @param {*} override
+     * @param {Object} props
+     * @returns {Object}
+     */
+    static applyEntityOverride(entityKey, baseConfig, override, props)
+    {
+        if('function' === typeof override && sc.hasOwn(override, 'propertiesConfig')){
+            return override.propertiesConfig(baseConfig, props);
+        }
+        if(sc.isFunction(override)){
+            return override(baseConfig, props);
+        }
+        if('object' === typeof override){
+            return sc.deepMergeProperties({}, baseConfig, override);
+        }
+        Logger.warning('Invalid override type for entity: '+entityKey);
+        return baseConfig;
+    }
+
+}
+
+module.exports.EntitiesConfigProcessor = EntitiesConfigProcessor;

package/lib/manager.js

@@ -13,6 +13,7 @@ const { AllowedExtensions } = require('./allowed-extensions');
 const { TemplatesToPathMapper } = require('./templates-to-path-mapper');
 const { AdminEntitiesGenerator } = require('./admin-entities-generator');
 const { LoadedEntitiesProcessor } = require('./loaded-entities-processor');
+const { EntitiesConfigProcessor } = require('./entities-config-processor');
 const { AdminManager } = require('./admin-manager');
 const { CmsPagesRouteManager } = require('./cms-pages-route-manager');
 const { Installer } = require('./installer');
@@ -41,6 +42,7 @@ class Manager
         this.rawRegisteredEntities = sc.get(props, 'rawRegisteredEntities', {});
         this.entitiesTranslations = sc.get(props, 'entitiesTranslations', {});
         this.entitiesConfig = sc.get(props, 'entitiesConfig', {});
+        this.entitiesConfigOverride = sc.get(props, 'entitiesConfigOverride', {});
         this.processedEntities = sc.get(props, 'processedEntities', {});
         this.entityAccess = sc.get(props, 'entityAccess', {});
         this.authenticationMethod = sc.get(props, 'authenticationMethod', 'db-users');
@@ -92,7 +94,11 @@ class Manager
         this.developmentExternalDomains = sc.get(props, 'developmentExternalDomains', {});
         this.appServerFactory = new AppServerFactory();
         this.adminEntitiesGenerator = new AdminEntitiesGenerator();
-        this.cacheManager = new CacheManager({projectRoot: this.projectRoot, enabled: this.cache});
+        this.cacheManager = new CacheManager({
+            projectRoot: this.projectRoot,
+            enabled: this.cache,
+            domainMapping: this.domainMapping
+        });
         this.templateReloader = new TemplateReloader({
             reloadTime: this.reloadTime,
             events: this.events,
@@ -439,10 +445,15 @@ class Manager
     loadProcessedEntities()
     {
         if(0 === Object.keys(this.processedEntities).length){
+            let mergedConfig = EntitiesConfigProcessor.applyOverrides(
+                this.entitiesConfig,
+                this.entitiesConfigOverride,
+                {projectRoot: this.projectRoot}
+            );
             this.processedEntities = LoadedEntitiesProcessor.process(
                 this.rawRegisteredEntities,
                 this.entitiesTranslations,
-                this.entitiesConfig
+                mergedConfig
             );
         }
         if(!this.processedEntities?.entities){

package/lib/template-reloader.js

@@ -247,12 +247,12 @@ class TemplateReloader
         if(!this.shouldReloadAdminTemplates(this.mappedAdminTemplates)){
             return false;
         }
-        let newAdminFilesContents = await this.adminTemplatesLoader.fetchAdminFilesContents(this.mappedAdminTemplates);
-        if(!newAdminFilesContents){
+        let adminFilesContents = await this.adminTemplatesLoader.fetchAdminFilesContents(this.mappedAdminTemplates);
+        if(!adminFilesContents){
             return false;
         }
         this.markTemplatesAsReloaded(this.mappedAdminTemplates);
-        return newAdminFilesContents;
+        return adminFilesContents;
     }
 
     async checkAndReloadFrontendTemplates()
@@ -265,16 +265,16 @@ class TemplateReloader
         return true;
     }
 
-    async updateAdminContentsAfterReload(newAdminFilesContents, adminManager)
+    async updateAdminContentsAfterReload(adminFilesContents, adminManager)
     {
-        if(!newAdminFilesContents || !adminManager){
+        if(!adminFilesContents || !adminManager){
             return false;
         }
-        adminManager.adminFilesContents = newAdminFilesContents;
-        adminManager.contentsBuilder.adminFilesContents = newAdminFilesContents;
-        adminManager.routerContents.adminFilesContents = newAdminFilesContents;
-        adminManager.addCacheButtonSubscriber.cacheCleanButton = newAdminFilesContents.cacheCleanButton;
-        adminManager.addCacheButtonSubscriber.clearAllCacheButton = newAdminFilesContents.clearAllCacheButton;
+        adminManager.adminFilesContents = adminFilesContents;
+        adminManager.contentsBuilder.adminFilesContents = adminFilesContents;
+        adminManager.routerContents.adminFilesContents = adminFilesContents;
+        adminManager.addCacheButtonSubscriber.cacheCleanButton = adminFilesContents.cacheCleanButton;
+        adminManager.addCacheButtonSubscriber.clearAllCacheButton = adminFilesContents.clearAllCacheButton;
         await adminManager.contentsBuilder.buildAdminContents();
         return true;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/cms",
     "scope": "@reldens",
-    "version": "0.49.0",
+    "version": "0.50.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",