@reldens/cms 0.50.0 → 0.52.0

package/.claude/sitemap-generator-guide.md

@@ -0,0 +1,511 @@
+# Sitemap Generator Guide
+
+## Overview
+
+The Sitemap Generator is a CLI tool and service class that automatically generates sitemap.xml files from enabled CMS routes. It supports multi-domain configurations and creates both domain-specific sitemaps and a sitemap index file.
+
+## Key Features
+
+- Loads enabled routes from `routes` table
+- Generates sitemap.xml per domain
+- Creates sitemap index pointing to all domain sitemaps
+- Supports optional single-domain generation
+- Uses domain public URL mapping for correct URLs
+- Includes route metadata (lastmod from updated_at)
+- XML generation via template strings with placeholders
+
+## CLI Command Usage
+
+### Basic Usage
+
+```bash
+# Generate sitemaps for all domains
+npx reldens-cms-generate-sitemap
+
+# Generate sitemap for specific domain only
+npx reldens-cms-generate-sitemap --domain=example.com
+
+# Show help
+npx reldens-cms-generate-sitemap --help
+npx reldens-cms-generate-sitemap -h
+```
+
+### Options
+
+- `--domain=[domain]` - Generate sitemap for specific domain only
+- `--help` or `-h` - Show help message
+
+### Requirements
+
+- CMS must be installed (install.lock exists)
+- Database must be accessible
+- Routes entity must be available
+- Generated entities must exist (run `npx reldens-cms-generate-entities` first)
+
+## Generated File Structure
+
+```
+[project-root]/
+├── public/
+│   ├── sitemap.xml                          # Sitemap index (all domains)
+│   └── sitemap/
+│       ├── example.com/
+│       │   └── sitemap.xml                  # Domain-specific sitemap
+│       ├── dev.example.com/
+│       │   └── sitemap.xml
+│       └── another-domain.com/
+│           └── sitemap.xml
+```
+
+### Sitemap Index Format
+
+Located at `public/sitemap.xml`:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <sitemap>
+    <loc>https://example.com/sitemap/example.com/sitemap.xml</loc>
+  </sitemap>
+  <sitemap>
+    <loc>https://dev.example.com/sitemap/dev.example.com/sitemap.xml</loc>
+  </sitemap>
+</sitemapindex>
+```
+
+### Domain Sitemap Format
+
+Located at `public/sitemap/[domain]/sitemap.xml`:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://example.com/</loc>
+    <lastmod>2025-01-15</lastmod>
+  </url>
+  <url>
+    <loc>https://example.com/about</loc>
+    <lastmod>2025-01-14</lastmod>
+  </url>
+  <url>
+    <loc>https://example.com/contact</loc>
+    <lastmod>2025-01-13</lastmod>
+  </url>
+</urlset>
+```
+
+## SitemapGenerator Class
+
+### Location
+
+`lib/sitemap-generator.js`
+
+### Constructor Parameters
+
+```javascript
+new SitemapGenerator({
+    dataServer,              // Required - DataServer instance
+    projectRoot,             // Required - Project root path
+    defaultDomain,           // Optional - Default domain for routes without domain
+    domainMapping,           // Optional - Domain to site key mapping
+    domainPublicUrlMapping   // Optional - Domain to public URL mapping
+})
+```
+
+### Key Methods
+
+**generate(specificDomain = null)**
+- Main entry point for sitemap generation
+- Loads enabled routes from database
+- Filters routes by domain if specified
+- Groups routes by domain
+- Generates sitemap files
+- Generates sitemap index (if no specific domain)
+- Returns boolean success status
+
+**loadEnabledRoutes()**
+- Queries `routes` entity with `{enabled: 1}` filter
+- Returns array of route objects or false on error
+- Logs critical errors if routes entity not found
+
+**groupRoutesByDomain(routes)**
+- Groups routes by domain field
+- Uses `defaultDomain` for routes without domain
+- Returns object: `{domain: [routes]}`
+
+**buildSitemapXml(routes, domain)**
+- Generates sitemap XML string for routes array
+- Builds URL entries with loc and lastmod tags
+- Uses `sc.sanitize()` for XML escaping
+- Uses `sc.formatDate(new Date(route.updated_at), 'Y-m-d')` for date formatting
+- Returns complete XML string with template placeholders replaced
+
+**buildSitemapIndexXml(domainRoutes)**
+- Generates sitemap index XML string
+- Creates sitemap entries pointing to domain sitemaps
+- Uses `sc.sanitize()` for XML escaping
+- Returns complete XML string with template placeholders replaced
+
+**buildUrl(domain, path)**
+- Constructs full URL from domain and path
+- Uses `domainPublicUrlMapping` for base URL
+- Defaults to `http://[domain]` if no mapping exists
+- Ensures proper slash handling (removes trailing, adds leading)
+
+**saveSitemaps(domainRoutes)**
+- Creates domain-specific directories under `public/sitemap/`
+- Writes sitemap.xml for each domain
+- Uses `FileHandler.createFolder()` and `FileHandler.writeFile()`
+- Returns false if any operation fails
+
+**saveSitemapIndex(domainRoutes)**
+- Creates `public/sitemap/` directory if needed
+- Writes sitemap index to `public/sitemap.xml`
+- Returns false if operation fails
+
+**getSitemapTemplate()**
+- Returns XML template string with `{{URLS}}` placeholder
+- Used by `buildSitemapXml()`
+
+**getSitemapIndexTemplate()**
+- Returns XML template string with `{{SITEMAPS}}` placeholder
+- Used by `buildSitemapIndexXml()`
+
+## XML Template Approach
+
+The generator uses simple template strings with placeholders instead of file-based templates or raw string concatenation.
+
+### Template Methods
+
+```javascript
+getSitemapTemplate()
+{
+    return '<?xml version="1.0" encoding="UTF-8"?>\n'
+        +'<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'
+        +'{{URLS}}\n'
+        +'</urlset>\n';
+}
+
+getSitemapIndexTemplate()
+{
+    return '<?xml version="1.0" encoding="UTF-8"?>\n'
+        +'<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'
+        +'{{SITEMAPS}}\n'
+        +'</sitemapindex>\n';
+}
+```
+
+### Placeholder Replacement
+
+- `{{URLS}}` - Replaced with array of URL entries joined by newlines
+- `{{SITEMAPS}}` - Replaced with array of sitemap entries joined by newlines
+
+### Entry Generation
+
+```javascript
+// URL entry
+let urlEntry = '  <url>\n';
+urlEntry += '    <loc>'+sc.sanitize(this.buildUrl(domain, route.path))+'</loc>\n';
+if(route.updated_at){
+    urlEntry += '    <lastmod>'+sc.formatDate(new Date(route.updated_at), 'Y-m-d')+'</lastmod>\n';
+}
+urlEntry += '  </url>';
+
+// Sitemap entry
+let sitemapEntry = '  <sitemap>\n';
+sitemapEntry += '    <loc>'+sc.sanitize(this.buildUrl(domain, '/sitemap/'+domain+'/sitemap.xml'))+'</loc>\n';
+sitemapEntry += '  </sitemap>';
+```
+
+## Multi-Domain Support
+
+### Configuration
+
+Multi-domain support relies on Manager configuration passed to SitemapGenerator:
+
+```javascript
+// In Manager
+this.defaultDomain = process.env.RELDENS_DEFAULT_DOMAIN || '';
+this.domainMapping = this.parseDomainMapping(process.env.RELDENS_DOMAIN_MAPPING || '{}');
+this.domainPublicUrlMapping = this.parseDomainMapping(process.env.RELDENS_DOMAIN_PUBLIC_URL_MAPPING || '{}');
+
+// Passed to SitemapGenerator
+let sitemapGenerator = new SitemapGenerator({
+    dataServer: manager.dataServer,
+    projectRoot: this.projectRoot,
+    defaultDomain: manager.defaultDomain,
+    domainMapping: manager.domainMapping,
+    domainPublicUrlMapping: manager.domainPublicUrlMapping
+});
+```
+
+### Environment Variables
+
+```bash
+# .env
+RELDENS_DEFAULT_DOMAIN=example.com
+RELDENS_DOMAIN_MAPPING={"dev.example.com":"development","staging.example.com":"staging"}
+RELDENS_DOMAIN_PUBLIC_URL_MAPPING={"example.com":"https://www.example.com","dev.example.com":"https://dev.example.com"}
+```
+
+### Domain Resolution
+
+1. Route has `domain` field → use route.domain
+2. Route has no domain → use `defaultDomain`
+3. No defaultDomain → use 'default'
+
+### URL Generation
+
+1. Check `domainPublicUrlMapping` for domain
+2. Use mapped URL if exists
+3. Default to `http://[domain]` if no mapping
+
+## Integration with Routes Entity
+
+### Routes Table Structure
+
+Required fields for sitemap generation:
+
+- `id` - Primary key
+- `path` - Route path (e.g., '/', '/about', '/contact')
+- `enabled` - Boolean flag (1 = enabled, 0 = disabled)
+- `domain` - Optional domain assignment
+- `updated_at` - Optional timestamp for lastmod
+
+### Query
+
+```javascript
+let routes = await routesEntity.load({enabled: 1});
+```
+
+Only enabled routes are included in sitemaps. Disabled routes are excluded.
+
+### Path Format
+
+- Paths should start with '/' (added automatically if missing)
+- Full URLs constructed: `https://example.com/path`
+
+## CLI Implementation
+
+### Location
+
+`bin/reldens-cms-generate-sitemap.js`
+
+### Class Structure
+
+**CmsSitemapGenerator**
+- Constructor: Parses command line arguments
+- `parseArguments()` - Extracts config from process.argv
+- `shouldShowHelp()` - Checks for help flags
+- `showHelp()` - Displays usage information
+- `run()` - Main execution flow
+
+### Execution Flow
+
+1. Check for help flag → show help and exit
+2. Extract domain parameter (if provided)
+3. Load .env file from project root
+4. Detect storage driver from environment
+5. Load entities using EntitiesLoader
+6. Create Manager instance with loaded entities
+7. Verify CMS installation
+8. Initialize DataServer
+9. Create SitemapGenerator instance
+10. Call `generate(domain)` method
+11. Log success/failure and exit
+
+### Dependencies
+
+```javascript
+const { Manager } = require('../index');
+const { SitemapGenerator } = require('../lib/sitemap-generator');
+const { EntitiesLoader } = require('../lib/entities-loader');
+const { PrismaClientLoader } = require('@reldens/storage');
+const { Logger, sc } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+const dotenv = require('dotenv');
+```
+
+## Programmatic Usage
+
+### Basic Example
+
+```javascript
+const { Manager } = require('@reldens/cms');
+const { SitemapGenerator } = require('@reldens/cms/lib/sitemap-generator');
+
+let manager = new Manager({projectRoot: process.cwd()});
+await manager.initializeDataServer();
+
+let sitemapGenerator = new SitemapGenerator({
+    dataServer: manager.dataServer,
+    projectRoot: process.cwd(),
+    defaultDomain: manager.defaultDomain,
+    domainMapping: manager.domainMapping,
+    domainPublicUrlMapping: manager.domainPublicUrlMapping
+});
+
+// Generate all sitemaps
+let success = await sitemapGenerator.generate();
+
+// Generate for specific domain
+let successSingle = await sitemapGenerator.generate('example.com');
+```
+
+### Custom Integration
+
+```javascript
+// In your application after CMS startup
+let manager = require('./path/to/cms-manager-instance');
+let { SitemapGenerator } = require('@reldens/cms/lib/sitemap-generator');
+
+// Generate sitemaps on schedule (e.g., daily cron job)
+async function regenerateSitemaps() {
+    let generator = new SitemapGenerator({
+        dataServer: manager.dataServer,
+        projectRoot: manager.projectRoot,
+        defaultDomain: manager.defaultDomain,
+        domainMapping: manager.domainMapping,
+        domainPublicUrlMapping: manager.domainPublicUrlMapping
+    });
+
+    let success = await generator.generate();
+    if(success){
+        console.log('Sitemaps regenerated successfully');
+    }
+}
+
+// Regenerate on route changes
+manager.eventsManager.on('reldens.routeSaved', async () => {
+    await regenerateSitemaps();
+});
+```
+
+## Error Handling
+
+### Common Errors
+
+**DataServer not provided**
+```
+CRITICAL: DataServer is required for sitemap generation.
+```
+Solution: Ensure DataServer is initialized and passed to constructor
+
+**Routes entity not found**
+```
+CRITICAL: Routes entity not found in dataServer.
+```
+Solution: Run `npx reldens-cms-generate-entities` to generate entities
+
+**Failed to load routes**
+```
+CRITICAL: Failed to load routes: [error message]
+```
+Solution: Check database connection and routes table existence
+
+**Directory creation failed**
+```
+CRITICAL: Failed to create sitemap directory: [path]
+```
+Solution: Check filesystem permissions for public folder
+
+**File write failed**
+```
+CRITICAL: Failed to write sitemap: [path]
+```
+Solution: Check filesystem permissions and disk space
+
+**No enabled routes**
+```
+WARNING: No enabled routes found for sitemap generation.
+```
+Not an error - returns true but no files generated
+
+**No routes for specific domain**
+```
+WARNING: No routes found for domain: [domain]
+```
+Not an error - returns true but no files generated for that domain
+
+### Debug Logging
+
+Set environment variable for detailed logging:
+
+```bash
+RELDENS_LOG_LEVEL=9 npx reldens-cms-generate-sitemap
+```
+
+## Best Practices
+
+1. **Regenerate on Route Changes**: Set up event listeners to regenerate sitemaps when routes are created, updated, or deleted
+2. **Schedule Regular Generation**: Run CLI command daily or weekly via cron job to ensure sitemaps stay current
+3. **Use Domain Mapping**: Configure `RELDENS_DOMAIN_PUBLIC_URL_MAPPING` for production URLs (especially for CDN or www subdomain)
+4. **Submit to Search Engines**: Submit sitemap index URL to Google Search Console and Bing Webmaster Tools
+5. **Monitor File Sizes**: Large sitemaps (>50k URLs) should be split - consider filtering by category or date
+6. **Set updated_at Properly**: Ensure routes table has accurate updated_at timestamps for lastmod accuracy
+7. **Enable Only Public Routes**: Use enabled=1 flag to control which routes appear in sitemaps
+
+## SEO Integration
+
+### Robots.txt
+
+Add sitemap reference to robots.txt:
+
+```
+User-agent: *
+Allow: /
+
+Sitemap: https://example.com/sitemap.xml
+```
+
+### Search Console
+
+1. Go to Google Search Console
+2. Add property for your domain
+3. Navigate to Sitemaps section
+4. Submit: `https://example.com/sitemap.xml`
+5. Monitor indexing status
+
+### Multi-Domain SEO
+
+Each domain gets its own sitemap, referenced in the index:
+
+```xml
+<sitemapindex>
+  <sitemap>
+    <loc>https://example.com/sitemap/example.com/sitemap.xml</loc>
+  </sitemap>
+  <sitemap>
+    <loc>https://blog.example.com/sitemap/blog.example.com/sitemap.xml</loc>
+  </sitemap>
+</sitemapindex>
+```
+
+Submit the index URL to search engines, or submit individual domain sitemaps to domain-specific Search Console properties.
+
+## Troubleshooting
+
+**Issue**: Sitemaps not updating
+- Solution: Check if routes have `enabled=1` flag
+- Solution: Verify `updated_at` field is being updated on route changes
+- Solution: Delete existing sitemaps and regenerate
+
+**Issue**: Wrong URLs in sitemap
+- Solution: Check `RELDENS_DOMAIN_PUBLIC_URL_MAPPING` configuration
+- Solution: Verify route `domain` field matches configured domains
+- Solution: Check `defaultDomain` setting
+
+**Issue**: CLI command not found
+- Solution: Run `npm install` to ensure bin scripts are linked
+- Solution: Use `npx reldens-cms-generate-sitemap` instead of direct path
+
+**Issue**: Permission denied errors
+- Solution: Check filesystem permissions on public folder
+- Solution: Run command with appropriate user permissions
+- Solution: Ensure public/sitemap directories are writable
+
+**Issue**: Empty sitemaps generated
+- Solution: Check if routes exist with `enabled=1`
+- Solution: Verify database connection
+- Solution: Check entity generation completed successfully

package/CLAUDE.md

@@ -28,10 +28,16 @@ npx reldens-cms-generate-entities
 # Update user password via CLI
 npx reldens-cms-update-password --email=admin@example.com
 
+# Generate sitemap.xml files from routes
+npx reldens-cms-generate-sitemap
+npx reldens-cms-generate-sitemap --domain=example.com
+
 # Or via npm scripts
 npm run generate-entities
 ```
 
+See `.claude/sitemap-generator-guide.md` for comprehensive sitemap generation documentation.
+
 ## Password Management
 
 ### CLI Password Update Command
@@ -719,4 +725,8 @@ See `.claude/advanced-usage-guide.md` for detailed examples.
 
 - Main README.md for user documentation
 - Package.json for dependency versions
+- `.claude/sitemap-generator-guide.md` - Sitemap generation documentation
+- `.claude/password-management-guide.md` - Password management documentation
+- `.claude/templating-system-guide.md` - Template system documentation
+- `.claude/advanced-usage-guide.md` - Advanced customization patterns
 - License: MIT

package/admin/templates/sections/editForm/cms-pages.html

@@ -1,5 +1,8 @@
 <fieldset class="cms-page-route">
     <legend>Route data</legend>
+    {{#originalRouteId}}
+    <input type="hidden" name="originalRouteId" value="{{originalRouteId}}"/>
+    {{/originalRouteId}}
     <div class="edit-field">
         <span class="field-name">Path</span>
         <span class="field-value">

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  *
@@ -7,6 +7,7 @@
  */
 
 const { Manager } = require('../index');
+const { PrismaClientLoader } = require('@reldens/storage');
 const { Logger, sc } = require('@reldens/utils');
 const { FileHandler } = require('@reldens/server-utils');
 const readline = require('readline');
@@ -108,7 +109,7 @@ class CmsEntitiesGenerator
         }
         let managerConfig = {projectRoot: this.projectRoot};
         if('prisma' === this.driver){
-            let prismaClient = await this.loadPrismaClient();
+            let prismaClient = PrismaClientLoader.load(this.projectRoot, this.prismaClientPath, null);
             if(prismaClient){
                 managerConfig.prismaClient = prismaClient;
             }
@@ -134,34 +135,6 @@ class CmsEntitiesGenerator
         return true;
     }
 
-    async loadPrismaClient()
-    {
-        let clientPath = this.prismaClientPath;
-        if(!clientPath){
-            return false;
-        }
-        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(resolvedPath);
-            let PrismaClient = PrismaClientModule.PrismaClient || PrismaClientModule.default?.PrismaClient;
-            if(!PrismaClient){
-                Logger.error('PrismaClient not found in module: '+resolvedPath);
-                return false;
-            }
-            Logger.debug('Prisma client loaded from: '+resolvedPath);
-            return new PrismaClient();
-        } catch (error) {
-            Logger.error('Failed to load Prisma client from '+resolvedPath+': '+error.message);
-            return false;
-        }
-    }
-
     async confirmOverride()
     {
         let rl = readline.createInterface({

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

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+
+/**
+ *
+ * Reldens - CMS - Generate Sitemap CLI
+ *
+ */
+
+const { Manager } = require('../index');
+const { SitemapGenerator } = require('../lib/sitemap-generator');
+const { EntitiesLoader } = require('../lib/entities-loader');
+const { PrismaClientLoader } = require('@reldens/storage');
+const { Logger, sc } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+const dotenv = require('dotenv');
+
+class CmsSitemapGenerator
+{
+
+    constructor()
+    {
+        this.args = process.argv.slice(2);
+        this.projectRoot = process.cwd();
+        this.config = {};
+        this.parseArguments();
+    }
+
+    parseArguments()
+    {
+        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('help' === flag || 'h' === flag){
+                    this.config[flag] = true;
+                }
+                continue;
+            }
+            this.config[arg.substring(2, equalIndex)] = arg.substring(equalIndex+1);
+        }
+    }
+
+    shouldShowHelp()
+    {
+        return sc.get(this.config, 'help', false) || sc.get(this.config, 'h', false);
+    }
+
+    showHelp()
+    {
+        Logger.info('');
+        Logger.info('Reldens CMS Sitemap Generator');
+        Logger.info('=============================');
+        Logger.info('');
+        Logger.info('Usage: npx reldens-cms-generate-sitemap [options]');
+        Logger.info('');
+        Logger.info('Options:');
+        Logger.info('  --domain=[domain]                Generate sitemap for specific domain');
+        Logger.info('  --help, -h                       Show this help message');
+        Logger.info('');
+        Logger.info('Examples:');
+        Logger.info('  npx reldens-cms-generate-sitemap');
+        Logger.info('  npx reldens-cms-generate-sitemap --domain=example.com');
+        Logger.info('  npx reldens-cms-generate-sitemap --help');
+        Logger.info('');
+        Logger.info('Note: Generates sitemap.xml files from enabled CMS routes.');
+        Logger.info('Note: Files are saved to public/sitemap/[domain]/sitemap.xml');
+        Logger.info('Note: A sitemap index is created at public/sitemap.xml');
+        Logger.info('');
+    }
+
+    async run()
+    {
+        if(this.shouldShowHelp()){
+            this.showHelp();
+            return true;
+        }
+        let domain = sc.get(this.config, 'domain', null);
+        let envFilePath = FileHandler.joinPaths(this.projectRoot, '.env');
+        dotenv.config({path: envFilePath});
+        let storageDriver = process.env.RELDENS_STORAGE_DRIVER || 'prisma';
+        Logger.debug('Using storage driver: '+storageDriver);
+        let entitiesLoader = new EntitiesLoader({projectRoot: this.projectRoot});
+        let loadedEntities = entitiesLoader.loadEntities(storageDriver);
+        if(!loadedEntities || !loadedEntities.rawRegisteredEntities){
+            Logger.error('Failed to load entities for driver: '+storageDriver);
+            Logger.error('Make sure you have run "npx reldens-cms-generate-entities" first.');
+            return false;
+        }
+        Logger.debug('Loaded entities for driver: '+storageDriver);
+        let managerConfig = {
+            projectRoot: this.projectRoot,
+            rawRegisteredEntities: loadedEntities.rawRegisteredEntities,
+            entitiesConfig: loadedEntities.entitiesConfig,
+            entitiesTranslations: loadedEntities.entitiesTranslations
+        };
+        if('prisma' === storageDriver){
+            let prismaClient = PrismaClientLoader.load(this.projectRoot, null, null);
+            if(prismaClient){
+                managerConfig.prismaClient = prismaClient;
+                Logger.debug('Prisma client loaded and configured.');
+            }
+        }
+        let manager = new Manager(managerConfig);
+        if(!manager.isInstalled()){
+            Logger.error('CMS is not installed. Please run installation first.');
+            return false;
+        }
+        Logger.debug('Reldens CMS Manager instance created for sitemap generation.');
+        if(!await manager.initializeDataServer()){
+            Logger.error('Failed to initialize data server.');
+            return false;
+        }
+        Logger.debug('Data server initialized successfully.');
+        let sitemapGenerator = new SitemapGenerator({
+            dataServer: manager.dataServer,
+            projectRoot: this.projectRoot,
+            defaultDomain: manager.defaultDomain,
+            domainMapping: manager.domainMapping,
+            domainPublicUrlMapping: manager.domainPublicUrlMapping
+        });
+        if(!await sitemapGenerator.generate(domain)){
+            Logger.error('Sitemap generation failed.');
+            return false;
+        }
+        if(domain){
+            Logger.info('Sitemap generated successfully for domain: '+domain);
+        }
+        if(!domain){
+            Logger.info('Sitemaps generated successfully for all domains.');
+        }
+        return true;
+    }
+
+}
+
+let generator = new CmsSitemapGenerator();
+generator.run().then((success) => {
+    if(!success){
+        process.exit(1);
+    }
+    process.exit(0);
+}).catch((error) => {
+    Logger.critical('Error during sitemap generation: '+error.message);
+    process.exit(1);
+});

package/bin/reldens-cms-update-password.js

@@ -8,6 +8,7 @@
 
 const { Manager } = require('../index');
 const { EntitiesLoader } = require('../lib/entities-loader');
+const { PrismaClientLoader } = require('@reldens/storage');
 const { Logger, sc } = require('@reldens/utils');
 const { FileHandler, Encryptor } = require('@reldens/server-utils');
 const dotenv = require('dotenv');
@@ -127,7 +128,7 @@ class CmsPasswordUpdater
             entitiesTranslations: loadedEntities.entitiesTranslations
         };
         if('prisma' === storageDriver){
-            let prismaClient = this.loadPrismaClient();
+            let prismaClient = PrismaClientLoader.load(this.projectRoot, null, null);
             if(prismaClient){
                 managerConfig.prismaClient = prismaClient;
                 Logger.debug('Prisma client loaded and configured.');
@@ -154,22 +155,6 @@ class CmsPasswordUpdater
         return true;
     }
 
-    loadPrismaClient()
-    {
-        let clientPath = FileHandler.joinPaths(this.projectRoot, 'prisma', 'client');
-        if(!FileHandler.exists(clientPath)){
-            Logger.debug('Prisma client path not found: '+clientPath);
-            return false;
-        }
-        try {
-            let { PrismaClient } = require(clientPath);
-            return new PrismaClient();
-        } catch(error) {
-            Logger.error('Failed to load Prisma client: '+error.message);
-            return false;
-        }
-    }
-
     async promptPassword()
     {
         let rl = readline.createInterface({

package/lib/cms-pages-route-manager.js

@@ -52,6 +52,7 @@ class CmsPagesRouteManager
         if(!event.loadedEntity || !event.loadedEntity.route_id){
             event.renderedEditProperties.routePath = '';
             event.renderedEditProperties.routeDomain = '';
+            event.renderedEditProperties.originalRouteId = '';
             return true;
         }
         let routesRepository = this.dataServer.getEntity('routes');
@@ -62,6 +63,7 @@ class CmsPagesRouteManager
         let existingRoute = await routesRepository.loadById(event.loadedEntity.route_id);
         event.renderedEditProperties.routePath = sc.get(existingRoute, 'path', '');
         event.renderedEditProperties.routeDomain = sc.get(existingRoute, 'domain', '');
+        event.renderedEditProperties.originalRouteId = event.loadedEntity.route_id;
         return true;
     }
 
@@ -90,10 +92,14 @@ class CmsPagesRouteManager
             domain: sc.get(req.body, 'routeDomain', null)
         };
         let routeResult = false;
-        if(entityData.route_id){
+        let originalRouteId = sc.get(req.body, 'originalRouteId', false);
+        if(entityData.route_id && originalRouteId && entityData.route_id === originalRouteId){
             routeResult = await routesRepository.updateById(entityData.route_id, routePatchData);
+            if(!routeResult){
+                Logger.error('Route could not be updated.', routePatchData);
+            }
         }
-        if(!routeResult){
+        if(!routeResult && !originalRouteId){
             routeResult = await routesRepository.create(routePatchData);
             if(routeResult){
                 let pagesRepository = this.dataServer.getEntity('cmsPages');
@@ -104,9 +110,9 @@ class CmsPagesRouteManager
                     }
                 }
             }
-        }
-        if(!routeResult){
-            Logger.error('Route could not be saved.', routePatchData);
+            if(!routeResult){
+                Logger.error('Route could not be created.', routePatchData);
+            }
         }
         return routeResult;
     }

package/lib/sitemap-generator.js

@@ -0,0 +1,181 @@
+/**
+ *
+ * Reldens - CMS - SitemapGenerator
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+
+class SitemapGenerator
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.defaultDomain = sc.get(props, 'defaultDomain', '');
+        this.domainMapping = sc.get(props, 'domainMapping', {});
+        this.domainPublicUrlMapping = sc.get(props, 'domainPublicUrlMapping', {});
+        this.sitemapDir = FileHandler.joinPaths(this.projectRoot, 'public', 'sitemap');
+    }
+
+    async generate(specificDomain = null)
+    {
+        if(!this.dataServer){
+            Logger.critical('DataServer is required for sitemap generation.');
+            return false;
+        }
+        let routes = await this.loadEnabledRoutes();
+        if(!routes){
+            return false;
+        }
+        if(0 === routes.length){
+            Logger.warning('No enabled routes found for sitemap generation.');
+            return true;
+        }
+        let filteredRoutes = routes;
+        if(specificDomain){
+            filteredRoutes = routes.filter((route) => {
+                let routeDomain = route.domain || this.defaultDomain;
+                return routeDomain === specificDomain;
+            });
+            if(0 === filteredRoutes.length){
+                Logger.warning('No routes found for domain: '+specificDomain);
+                return true;
+            }
+        }
+        let domainRoutes = this.groupRoutesByDomain(filteredRoutes);
+        if(!await this.saveSitemaps(domainRoutes)){
+            return false;
+        }
+        if(!specificDomain){
+            if(!await this.saveSitemapIndex(domainRoutes)){
+                return false;
+            }
+        }
+        Logger.info('Sitemap generation completed successfully.');
+        return true;
+    }
+
+    async loadEnabledRoutes()
+    {
+        let routesEntity = this.dataServer.getEntity('routes');
+        if(!routesEntity){
+            Logger.critical('Routes entity not found in dataServer.');
+            return false;
+        }
+        try {
+            let routes = await routesEntity.load({enabled: 1});
+            Logger.debug('Loaded '+routes.length+' enabled routes.');
+            return routes;
+        } catch(error) {
+            Logger.critical('Failed to load routes: '+error.message);
+            return false;
+        }
+    }
+
+    groupRoutesByDomain(routes)
+    {
+        let domainRoutes = {};
+        for(let route of routes){
+            let domain = route.domain || this.defaultDomain || 'default';
+            if(!sc.hasOwn(domainRoutes, domain)){
+                domainRoutes[domain] = [];
+            }
+            domainRoutes[domain].push(route);
+        }
+        return domainRoutes;
+    }
+
+    buildSitemapXml(routes, domain)
+    {
+        let urlEntries = [];
+        for(let route of routes){
+            let urlEntry = '  <url>\n';
+            urlEntry += '    <loc>'+sc.sanitize(this.buildUrl(domain, route.path))+'</loc>\n';
+            if(route.updated_at){
+                urlEntry += '    <lastmod>'+sc.formatDate(new Date(route.updated_at), 'Y-m-d')+'</lastmod>\n';
+            }
+            urlEntry += '  </url>';
+            urlEntries.push(urlEntry);
+        }
+        return this.getSitemapTemplate().replace('{{URLS}}', urlEntries.join('\n'));
+    }
+
+    buildSitemapIndexXml(domainRoutes)
+    {
+        let sitemapEntries = [];
+        for(let domain in domainRoutes){
+            let sitemapEntry = '  <sitemap>\n';
+            sitemapEntry += '    <loc>'+sc.sanitize(this.buildUrl(domain, '/sitemap/'+domain+'/sitemap.xml'))+'</loc>\n';
+            sitemapEntry += '  </sitemap>';
+            sitemapEntries.push(sitemapEntry);
+        }
+        return this.getSitemapIndexTemplate().replace('{{SITEMAPS}}', sitemapEntries.join('\n'));
+    }
+
+    getSitemapTemplate()
+    {
+        return '<?xml version="1.0" encoding="UTF-8"?>\n'
+            +'<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'
+            +'{{URLS}}\n'
+            +'</urlset>\n';
+    }
+
+    getSitemapIndexTemplate()
+    {
+        return '<?xml version="1.0" encoding="UTF-8"?>\n'
+            +'<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'
+            +'{{SITEMAPS}}\n'
+            +'</sitemapindex>\n';
+    }
+
+    async saveSitemaps(domainRoutes)
+    {
+        for(let domain in domainRoutes){
+            let domainDir = FileHandler.joinPaths(this.sitemapDir, domain);
+            if(!FileHandler.createFolder(domainDir)){
+                Logger.critical('Failed to create sitemap directory: '+domainDir);
+                return false;
+            }
+            let sitemapPath = FileHandler.joinPaths(domainDir, 'sitemap.xml');
+            if(!FileHandler.writeFile(sitemapPath, this.buildSitemapXml(domainRoutes[domain], domain))){
+                Logger.critical('Failed to write sitemap: '+sitemapPath);
+                return false;
+            }
+            Logger.info('Sitemap saved: '+sitemapPath);
+        }
+        return true;
+    }
+
+    async saveSitemapIndex(domainRoutes)
+    {
+        if(!FileHandler.createFolder(this.sitemapDir)){
+            Logger.critical('Failed to create sitemap directory: '+this.sitemapDir);
+            return false;
+        }
+        let indexPath = FileHandler.joinPaths(this.projectRoot, 'public', 'sitemap.xml');
+        if(!FileHandler.writeFile(indexPath, this.buildSitemapIndexXml(domainRoutes))){
+            Logger.critical('Failed to write sitemap index: '+indexPath);
+            return false;
+        }
+        Logger.info('Sitemap index saved: '+indexPath);
+        return true;
+    }
+
+    buildUrl(domain, path)
+    {
+        let publicUrl = sc.get(this.domainPublicUrlMapping, domain, 'http://'+domain);
+        if(publicUrl.endsWith('/')){
+            publicUrl = publicUrl.slice(0, -1);
+        }
+        if(!path.startsWith('/')){
+            path = '/'+path;
+        }
+        return publicUrl+path;
+    }
+
+}
+
+module.exports.SitemapGenerator = SitemapGenerator;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/cms",
     "scope": "@reldens",
-    "version": "0.50.0",
+    "version": "0.52.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -13,7 +13,8 @@
     "bin": {
         "reldens-cms": "bin/reldens-cms.js",
         "reldens-cms-generate-entities": "bin/reldens-cms-generate-entities.js",
-        "reldens-cms-update-password": "bin/reldens-cms-update-password.js"
+        "reldens-cms-update-password": "bin/reldens-cms-update-password.js",
+        "reldens-cms-generate-sitemap": "bin/reldens-cms-generate-sitemap.js"
     },
     "repository": {
         "type": "git",
@@ -34,8 +35,8 @@
         "url": "https://github.com/damian-pastorini/reldens-cms/issues"
     },
     "dependencies": {
-        "@reldens/server-utils": "^0.43.0",
-        "@reldens/storage": "^0.85.0",
+        "@reldens/server-utils": "^0.44.0",
+        "@reldens/storage": "^0.87.0",
         "@reldens/utils": "^0.54.0",
         "dotenv": "17.2.3",
         "mustache": "4.2.0"