@reldens/cms 0.65.0 → 0.67.0

package/.claude/api-reference.md

@@ -4,14 +4,39 @@
 
 - `start()` - Initialize and start the CMS
 - `isInstalled()` - Check if CMS is installed
-- `initializeServices()` - Initialize all services
-- `validateProvidedServer()` - Validate provided server instance
-- `validateProvidedDataServer()` - Validate provided data server
-- `validateProvidedAdminManager()` - Validate provided admin manager
-- `validateProvidedFrontend()` - Validate provided frontend
 - `buildAppServerConfiguration()` - Build server configuration
+- `validateCdnMappingsInDevelopment()` - Warn when CDN domains are missing from CSP directives
+- `isCdnUrlInDirectives(cdnUrlWithProtocol, cdnHostname)` - Check if a CDN URL appears in any CSP directive
 - `initializeCmsAfterInstall(props)` - Post-installation callback
 
+## ManagerComponentValidator Class (lib/manager-component-validator.js)
+
+Static validators called from the Manager constructor:
+
+- `validateProvidedServer(app, appServer)` - Validate provided Express app and server
+- `validateProvidedDataServer(dataServer)` - Validate provided data server
+- `validateProvidedAdminManager(adminManager)` - Validate provided admin manager
+- `validateProvidedFrontend(frontend)` - Validate provided frontend
+
+## ManagerConfigLoader Class (lib/manager-config-loader.js)
+
+- `loadFromEnv()` - Build config object from `RELDENS_*` environment variables
+
+## ManagerServicesInitializer Class (lib/manager-services-initializer.js)
+
+Receives the Manager instance via constructor and handles all service initialization:
+
+- `initializeServices()` - Orchestrate full service initialization sequence
+- `initializeDataServer()` - Create data server; auto-creates PrismaClient via PrismaClientLoader when driver is `prisma` and no client provided
+- `setupEntityAccess()` - Sync entity access rules to database
+- `loadProcessedEntities()` - Apply config overrides and process raw entities
+- `generateAdminEntities()` - Generate admin panel entity definitions
+- `initializeAdminManager()` - Set up admin routes and authentication
+- `initializePasswordEncryptionHandler()` - Register password encryption event listeners
+- `initializeCmsPagesRouteManager()` - Wire CMS page routes to the data server
+- `initializeFrontend()` - Create and initialize Frontend instance
+- `renderCallback(template, params)` - Render a template via the configured render engine
+
 ## Installer Class
 
 - `isInstalled()` - Check installation status

package/.claude/architecture-guide.md

@@ -8,14 +8,20 @@
 
 Main CMS orchestrator that:
 
-- Initializes all services (data server, admin, frontend)
-- Handles configuration and environment variables
-- Manages multi-domain setup and security
-- Coordinates service lifecycle
-- Initializes password encryption handler
+- Coordinates service lifecycle and startup
+- Manages multi-domain setup and CDN validation
+- Builds app server configuration
+- Delegates service initialization to `ManagerServicesInitializer`
 - Defines default templateExtensions: `['.html', '.mustache', '.template', '.txt', '.xml', '.json']`
 - Passes templateExtensions to all frontend components ensuring consistency
 
+Responsibilities are split across four files:
+
+- `lib/manager.js` — orchestration, server config, lifecycle
+- `lib/manager-component-validator.js` — static validation of provided server/dataServer/adminManager/frontend instances
+- `lib/manager-config-loader.js` — static `loadFromEnv()` reading all `RELDENS_*` env vars into a config object
+- `lib/manager-services-initializer.js` — data server, admin, frontend, entity and route manager initialization; auto-creates `PrismaClient` via `PrismaClientLoader` from `@reldens/storage` when driver is `prisma` and no client is provided
+
 ### Frontend
 
 **File:** `lib/frontend.js`

package/.claude/installation-guide.md

@@ -6,12 +6,13 @@ The installer supports complex operations through subprocess management:
 
 ```javascript
 const { Installer } = require('@reldens/cms');
+const { Logger } = require('@reldens/utils');
 
-const installer = new Installer({
+let installer = new Installer({
     projectRoot: process.cwd(),
     subprocessMaxAttempts: 1800,
     postInstallCallback: async (props) => {
-        console.log('Entities loaded:', Object.keys(props.loadedEntities.rawRegisteredEntities));
+        Logger.info('Entities loaded: '+Object.keys(props.loadedEntities.rawRegisteredEntities).length);
         return true;
     }
 });
@@ -31,7 +32,7 @@ const installer = new Installer({
 The Manager class provides comprehensive service initialization:
 
 ```javascript
-const cms = new Manager({
+let cms = new Manager({
     app: customExpressApp,
     appServer: customAppServer,
     dataServer: customDataServer,
@@ -54,6 +55,7 @@ const cms = new Manager({
 
 - Validates all provided instances
 - Initializes missing services
+- Auto-creates `PrismaClient` via `PrismaClientLoader` from `@reldens/storage` when `RELDENS_STORAGE_DRIVER=prisma` and no `prismaClient` is passed in — no Prisma imports needed in your entry point
 - Sets up entity access control
 - Generates admin entities
 - Configures template reloading
@@ -65,7 +67,7 @@ The CMS automatically detects development environments based on domain patterns.
 **Default Development Patterns:**
 
 ```javascript
-const patterns = [
+let patterns = [
     'localhost',
     '127.0.0.1',
     '.local',
@@ -84,7 +86,7 @@ const patterns = [
 **Override Development Patterns:**
 
 ```javascript
-const cms = new Manager({
+let cms = new Manager({
     developmentPatterns: [
         'localhost',
         '127.0.0.1',
@@ -109,7 +111,7 @@ const cms = new Manager({
 Configure external domains for CSP directives (kebab-case or camelCase):
 
 ```javascript
-const cms = new Manager({
+let cms = new Manager({
     appServerConfig: {
         developmentExternalDomains: {
             'scriptSrc': ['https://cdn.example.com'],
@@ -131,7 +133,7 @@ const cms = new Manager({
 **Default (merge with base directives):**
 
 ```javascript
-const cms = new Manager({
+let cms = new Manager({
     appServerConfig: {
         helmetConfig: {
             contentSecurityPolicy: {
@@ -165,7 +167,7 @@ const cms = new Manager({
 **Complete Replacement:**
 
 ```javascript
-const cms = new Manager({
+let cms = new Manager({
     appServerConfig: {
         helmetConfig: {
             contentSecurityPolicy: {
@@ -190,7 +192,7 @@ const cms = new Manager({
 ### Additional Helmet Security Headers
 
 ```javascript
-const cms = new Manager({
+let cms = new Manager({
     appServerConfig: {
         helmetConfig: {
             hsts: {

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  *

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  *

package/bin/reldens-cms.js

@@ -9,30 +9,24 @@
 const { Manager } = require('../index');
 const { Logger } = require('@reldens/utils');
 const { FileHandler } = require('@reldens/server-utils');
-const readline = require('readline');
+const { PrismaClientLoader } = require('@reldens/storage');
+const readline = require('readline/promises');
 const dotenv = require('dotenv');
 
 let args = process.argv.slice(2);
 let projectRoot = args[0] || process.cwd();
 let indexPath = FileHandler.joinPaths(projectRoot, 'index.js');
 
-if(FileHandler.exists(indexPath)){
-    require(indexPath);
-    return;
-}
-
 async function checkRequiredPackages(projectRoot)
 {
     let requiredPackages = ['@reldens/cms'];
     let missingPackages = [];
     for(let packageName of requiredPackages){
-        let packagePath = FileHandler.joinPaths(projectRoot, 'node_modules', packageName);
-        if(!FileHandler.exists(packagePath)){
+        if(!FileHandler.exists(FileHandler.joinPaths(projectRoot, 'node_modules', packageName))){
             missingPackages.push(packageName);
         }
     }
-    let packagePath = FileHandler.joinPaths(projectRoot, 'node_modules', '@prisma/client');
-    if(!FileHandler.exists(packagePath)){
+    if(!FileHandler.exists(FileHandler.joinPaths(projectRoot, 'node_modules', '@prisma/client'))){
         missingPackages.push('@prisma/client');
     }
     return missingPackages;
@@ -44,14 +38,11 @@ async function promptUserConfirmation(packages)
         input: process.stdin,
         output: process.stdout
     });
-    return new Promise((resolve) => {
-        Logger.info('Missing required packages: '+packages.join(', '));
-        Logger.info('These packages are required for the CMS to function properly.');
-        rl.question('Would you like to install them automatically? (y/N): ', (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
-        });
-    });
+    Logger.info('Missing required packages: '+packages.join(', '));
+    Logger.info('These packages are required for the CMS to function properly.');
+    let answer = await rl.question('Would you like to install them automatically? (y/N): ');
+    rl.close();
+    return 'y' === answer.toLowerCase() || 'yes' === answer.toLowerCase();
 }
 
 async function installPackages(packages, projectRoot)
@@ -59,8 +50,7 @@ async function installPackages(packages, projectRoot)
     try {
         Logger.info('Installing packages: npm install '+packages.join(' '));
         let {execSync} = require('child_process');
-        let installCommand = 'npm install '+packages.join(' ');
-        execSync(installCommand, {stdio: 'inherit', cwd: projectRoot});
+        execSync('npm install '+packages.join(' '), {stdio: 'inherit', cwd: projectRoot});
         Logger.info('Dependencies installed successfully.');
         return true;
     } catch(error) {
@@ -94,42 +84,35 @@ async function createPrismaClientIfNeeded(projectRoot)
     }
     let clientPath = FileHandler.joinPaths(projectRoot, 'prisma', 'client');
     if(!FileHandler.exists(clientPath)){
-        Logger.critical('Prisma client not found at: '+clientPath);
-        Logger.critical('Please run "npx prisma generate" to generate the Prisma client.');
-        return false;
-    }
-    try {
-        let { PrismaClient } = require(clientPath);
-        return new PrismaClient();
-    } catch(error) {
-        Logger.critical('Failed to initialize Prisma client: '+error.message);
         return false;
     }
+    return PrismaClientLoader.load(projectRoot, null, null) || false;
 }
 
-async function startManagerProcess()
+async function main()
 {
+    if(FileHandler.exists(indexPath)){
+        require(indexPath);
+        return;
+    }
     let packageInstallResult = await handlePackageInstallation(projectRoot);
     if(!packageInstallResult){
         process.exit(1);
     }
-
-let managerConfig = {projectRoot};
-let entitiesPath = FileHandler.joinPaths(
-    projectRoot,
-    'generated-entities',
-    'models',
-    'prisma',
-    'registered-models-prisma.js'
-);
-
-if(FileHandler.exists(entitiesPath)){
-    let entitiesModule = require(entitiesPath);
-    managerConfig.rawRegisteredEntities = entitiesModule.rawRegisteredEntities;
-    managerConfig.entitiesConfig = entitiesModule.entitiesConfig;
-    managerConfig.entitiesTranslations = entitiesModule.entitiesTranslations;
-}
-
+    let managerConfig = {projectRoot};
+    let entitiesPath = FileHandler.joinPaths(
+        projectRoot,
+        'generated-entities',
+        'models',
+        'prisma',
+        'registered-models-prisma.js'
+    );
+    if(FileHandler.exists(entitiesPath)){
+        let entitiesModule = require(entitiesPath);
+        managerConfig.rawRegisteredEntities = entitiesModule.rawRegisteredEntities;
+        managerConfig.entitiesConfig = entitiesModule.entitiesConfig;
+        managerConfig.entitiesTranslations = entitiesModule.entitiesTranslations;
+    }
     let prismaClient = await createPrismaClientIfNeeded(projectRoot);
     if(prismaClient){
         managerConfig.prismaClient = prismaClient;
@@ -149,7 +132,7 @@ if(FileHandler.exists(entitiesPath)){
     });
 }
 
-startManagerProcess().catch((error) => {
+main().catch((error) => {
     Logger.critical('Failed to handle package installation:', error);
     process.exit(1);
 });

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

@@ -491,7 +491,11 @@ class RouterContents
             driverResource,
             entityId: id
         });
-        return await entityRepository.loadByIdWithRelations(id);
+        let idProperty = this.fetchEntityIdPropertyKey(driverResource);
+        if(!idProperty){
+            return false;
+        }
+        return await entityRepository.loadOneByWithRelations(idProperty, id);
     }
 
     async saveEntity(id, entityRepository, entityDataPatch)

package/lib/manager-component-validator.js

@@ -0,0 +1,72 @@
+/**
+ *
+ * Reldens - CMS - Manager Component Validator
+ *
+ */
+
+const { Logger } = require('@reldens/utils');
+
+class ManagerComponentValidator
+{
+
+    static validateProvidedServer(app, appServer)
+    {
+        if(!app){
+            return false;
+        }
+        if(!appServer){
+            return false;
+        }
+        if('function' !== typeof app.use){
+            Logger.critical('Invalid app instance provided - missing use method.');
+            return false;
+        }
+        if('function' !== typeof appServer.listen){
+            Logger.critical('Invalid appServer instance provided - missing listen method.');
+            return false;
+        }
+        return true;
+    }
+
+    static validateProvidedDataServer(dataServer)
+    {
+        if(!dataServer){
+            return false;
+        }
+        if('function' !== typeof dataServer.connect){
+            Logger.critical('Invalid dataServer instance provided - missing connect method.');
+            return false;
+        }
+        if('function' !== typeof dataServer.generateEntities){
+            Logger.critical('Invalid dataServer instance provided - missing generateEntities method.');
+            return false;
+        }
+        return true;
+    }
+
+    static validateProvidedAdminManager(adminManager)
+    {
+        if(!adminManager){
+            return false;
+        }
+        if('function' !== typeof adminManager.setupAdmin){
+            Logger.critical('Invalid adminManager instance provided - missing setupAdmin method.');
+            return false;
+        }
+        return true;
+    }
+
+    static validateProvidedFrontend(frontend)
+    {
+        if(!frontend){
+            return false;
+        }
+        if('function' !== typeof frontend.initialize){
+            Logger.critical('Invalid frontend instance provided - missing initialize method.');
+            return false;
+        }
+        return true;
+    }
+}
+
+module.exports.ManagerComponentValidator = ManagerComponentValidator;

package/lib/manager-config-loader.js

@@ -0,0 +1,33 @@
+/**
+ *
+ * Reldens - CMS - Manager Config Loader
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class ManagerConfigLoader
+{
+
+    static loadFromEnv()
+    {
+        return {
+            host: sc.get(process.env, 'RELDENS_APP_HOST', 'http://localhost'),
+            port: Number(sc.get(process.env, 'RELDENS_APP_PORT', 8080)),
+            adminPath: sc.get(process.env, 'RELDENS_ADMIN_ROUTE_PATH', '/reldens-admin'),
+            adminSecret: sc.get(process.env, 'RELDENS_ADMIN_SECRET', ''),
+            database: {
+                client: sc.get(process.env, 'RELDENS_DB_CLIENT', 'mysql'),
+                host: sc.get(process.env, 'RELDENS_DB_HOST', 'localhost'),
+                port: Number(sc.get(process.env, 'RELDENS_DB_PORT', 3306)),
+                name: sc.get(process.env, 'RELDENS_DB_NAME', 'reldens_cms'),
+                user: sc.get(process.env, 'RELDENS_DB_USER', ''),
+                password: sc.get(process.env, 'RELDENS_DB_PASSWORD', ''),
+                driver: sc.get(process.env, 'RELDENS_STORAGE_DRIVER', 'prisma')
+            },
+            publicUrl: sc.get(process.env, 'RELDENS_PUBLIC_URL', '')
+        };
+    }
+}
+
+module.exports.ManagerConfigLoader = ManagerConfigLoader;