@reldens/cms 0.27.0 → 0.29.0

package/lib/mysql-installer.js

@@ -0,0 +1,93 @@
+/**
+ *
+ * Reldens - CMS - MySQLInstaller
+ *
+ */
+
+const { execSync } = require('child_process');
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger } = require('@reldens/utils');
+
+class MySQLInstaller
+{
+
+    static migrationFiles()
+    {
+        return {
+            'install-cms-tables': 'install.sql',
+            'install-user-auth': 'users-authentication.sql',
+            'install-default-user': 'default-user.sql',
+            'install-default-homepage': 'default-homepage.sql',
+            'install-default-blocks': 'default-blocks.sql',
+            'install-entity-access': 'default-entity-access.sql',
+            'install-dynamic-forms': 'default-forms.sql'
+        };
+    }
+
+    static async executeQueryFile(isMarked, fileName, dbDriver, migrationsPath)
+    {
+        if('on' !== isMarked){
+            return '';
+        }
+        let sqlFileContent = FileHandler.readFile(FileHandler.joinPaths(migrationsPath, fileName));
+        if(!sqlFileContent){
+            Logger.error('SQL file "'+fileName+'" not found.');
+            return '/?error=sql-file-not-found&file-name='+fileName;
+        }
+        let queryExecutionResult = await dbDriver.rawQuery(sqlFileContent);
+        if(!queryExecutionResult){
+            Logger.error('SQL file "'+fileName+'" raw execution failed.');
+            return '/?error=sql-file-execution-error&file-name='+fileName;
+        }
+        Logger.info('SQL file "'+fileName+'" raw execution successfully.');
+        return '';
+    }
+
+    static async generateMinimalPrismaClient(dbConfig, projectRoot)
+    {
+        let prismaPath = FileHandler.joinPaths(projectRoot, 'prisma');
+        let schemaPath = FileHandler.joinPaths(prismaPath, 'schema.prisma');
+        FileHandler.createFolder(prismaPath);
+        let schemaContent = 'generator client {\n'
+            + '  provider = "prisma-client-js"\n'
+            + '  output   = "./client"\n'
+            + '}\n'
+            + '\n'
+            + 'datasource db {\n'
+            + '  provider = "' + dbConfig.client + '"\n'
+            + '  url      = "' + dbConfig.client + '://' + dbConfig.config.user + ':' + dbConfig.config.password + '@'
+            + dbConfig.config.host + ':' + dbConfig.config.port + '/' + dbConfig.config.database + '"\n'
+            + '}';
+        FileHandler.writeFile(schemaPath, schemaContent);
+        Logger.info('Running prisma generate...');
+        try {
+            execSync('npx prisma generate', { stdio: 'inherit', cwd: projectRoot });
+            let clientPath = FileHandler.joinPaths(projectRoot, 'prisma', 'client');
+            let { PrismaClient } = require(clientPath);
+            return new PrismaClient();
+        } catch(error) {
+            Logger.error('Prisma generate failed: '+error.message);
+            return false;
+        }
+    }
+
+    static async createPrismaClient(projectRoot)
+    {
+        try {
+            let clientPath = FileHandler.joinPaths(projectRoot, 'prisma', 'client');
+            if(!FileHandler.exists(clientPath)){
+                return false;
+            }
+            const { PrismaClient } = require(clientPath);
+            let client = new PrismaClient();
+            await client.$connect();
+            return client;
+        } catch(error){
+            Logger.error('Prisma client creation failed: '+error.message);
+            return false;
+        }
+    }
+
+}
+
+module.exports.MySQLInstaller = MySQLInstaller;

package/lib/prisma-subprocess-worker.js

@@ -0,0 +1,97 @@
+/**
+ *
+ * Reldens - CMS - PrismaSubprocessWorker
+ *
+ */
+
+const { DriversMap } = require('@reldens/storage');
+const { MySQLInstaller } = require('./mysql-installer');
+const { Logger } = require('@reldens/utils');
+const { sc } = require('@reldens/utils');
+
+class PrismaSubprocessWorker
+{
+
+    constructor()
+    {
+        this.setupProcessHandlers();
+    }
+
+    setupProcessHandlers()
+    {
+        process.on('message', async (message) => {
+            try {
+                await this.processIncomingMessage(message);
+            } catch(error) {
+                Logger.error('PrismaSubprocessWorker error: '+error.message);
+                this.sendErrorResponse(error.message);
+                setTimeout(() => process.exit(1), 100);
+            }
+        });
+        process.on('uncaughtException', (error) => {
+            Logger.error('PrismaSubprocessWorker uncaught exception: '+error.message);
+            this.sendErrorResponse(error.message);
+            setTimeout(() => process.exit(1), 100);
+        });
+        process.on('unhandledRejection', (error) => {
+            Logger.error('PrismaSubprocessWorker unhandled rejection: '+error.message);
+            this.sendErrorResponse(error.message);
+            setTimeout(() => process.exit(1), 100);
+        });
+    }
+
+    async processIncomingMessage(message)
+    {
+        let dbConfig = sc.get(message, 'dbConfig', {});
+        let templateVariables = sc.get(message, 'templateVariables', {});
+        let migrationsPath = sc.get(message, 'migrationsPath', './migrations');
+        let projectRoot = sc.get(message, 'projectRoot', './');
+        let generatedClient = await MySQLInstaller.generateMinimalPrismaClient(dbConfig, projectRoot);
+        if(!generatedClient){
+            this.sendErrorResponse('Failed to generate Prisma client.');
+            return;
+        }
+        dbConfig.prismaClient = generatedClient;
+        let driverClass = DriversMap['prisma'];
+        if(!driverClass){
+            this.sendErrorResponse('Prisma driver class not found.');
+            return;
+        }
+        let dbDriver = new driverClass(dbConfig);
+        if(!await dbDriver.connect()){
+            this.sendErrorResponse('Database connection failed.');
+            return;
+        }
+        let migrationFiles = MySQLInstaller.migrationFiles();
+        for(let checkboxName of Object.keys(migrationFiles)){
+            let fileName = migrationFiles[checkboxName];
+            let redirectError = await MySQLInstaller.executeQueryFile(
+                sc.get(templateVariables, checkboxName, 'off'),
+                fileName,
+                dbDriver,
+                migrationsPath
+            );
+            if('' !== redirectError){
+                this.sendErrorResponse('Migration failed: '+fileName);
+                return;
+            }
+        }
+        await generatedClient.$disconnect();
+        this.sendSuccessResponse('Subprocess installation completed.');
+    }
+
+    sendSuccessResponse(message)
+    {
+        process.send({success: true, message: message});
+    }
+
+    sendErrorResponse(errorMessage)
+    {
+        process.send({success: false, error: errorMessage});
+    }
+
+}
+
+module.exports.PrismaSubprocessWorker = PrismaSubprocessWorker;
+
+new PrismaSubprocessWorker();

package/lib/template-engine/asset-transformer.js

@@ -1,41 +1,43 @@
-/**
- *
- * Reldens - CMS - AssetTransformer
- *
- */
-
-const { sc } = require('@reldens/utils');
-
-class AssetTransformer
-{
-
-    async transform(template, domain, req, systemVariables)
-    {
-        if(!template){
-            return template;
-        }
-        let currentRequest = sc.get(systemVariables, 'currentRequest', {});
-        let assetPattern = /\[asset\(([^)]+)\)\]/g;
-        let matches = [...template.matchAll(assetPattern)];
-        for(let i = matches.length - 1; i >= 0; i--){
-            let match = matches[i];
-            let assetPath = match[1].replace(/['"]/g, '');
-            let absoluteUrl = this.buildAssetUrl(assetPath, currentRequest);
-            template = template.substring(0, match.index) +
-                absoluteUrl +
-                template.substring(match.index + match[0].length);
-        }
-        return template;
-    }
-
-    buildAssetUrl(assetPath, currentRequest)
-    {
-        if(!assetPath || assetPath.startsWith('http')){
-            return assetPath;
-        }
-        return sc.get(currentRequest, 'baseUrl', '')+'/assets'+(assetPath.startsWith('/') ? assetPath : '/'+assetPath);
-    }
-
-}
-
-module.exports.AssetTransformer = AssetTransformer;
+/**
+ *
+ * Reldens - CMS - AssetTransformer
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class AssetTransformer
+{
+
+    async transform(template, domain, req, systemVariables)
+    {
+        if(!template){
+            return template;
+        }
+        let currentRequest = sc.get(systemVariables, 'currentRequest', {});
+        let assetPattern = /\[asset\(([^)]+)\)\]/g;
+        let matches = [...template.matchAll(assetPattern)];
+        for(let i = matches.length - 1; i >= 0; i--){
+            let match = matches[i];
+            let assetPath = match[1].replace(/['"]/g, '');
+            let absoluteUrl = this.buildAssetUrl(assetPath, currentRequest);
+            template = template.substring(0, match.index) +
+                absoluteUrl +
+                template.substring(match.index + match[0].length);
+        }
+        return template;
+    }
+
+    buildAssetUrl(assetPath, currentRequest)
+    {
+        if(!assetPath || assetPath.startsWith('http')){
+            return assetPath;
+        }
+        return sc.get(currentRequest, 'publicUrl', '')
+            +'/assets'
+            +(assetPath.startsWith('/') ? assetPath : '/'+assetPath);
+    }
+
+}
+
+module.exports.AssetTransformer = AssetTransformer;

package/lib/template-engine/date-transformer.js

@@ -38,12 +38,11 @@ class DateTransformer
     {
         let date;
         if(!dateValue || '' === dateValue || 'now' === dateValue.toLowerCase()){
+            return sc.formatDate(new Date(), format);
+        }
+        date = new Date(dateValue);
+        if(isNaN(date.getTime())){
             date = new Date();
-        } else {
-            date = new Date(dateValue);
-            if(isNaN(date.getTime())){
-                date = new Date();
-            }
         }
         return sc.formatDate(date, format);
     }

package/lib/template-engine/system-variables-provider.js

@@ -1,108 +1,127 @@
-/**
- *
- * Reldens - CMS - SystemVariablesProvider
- *
- */
-
-const { sc } = require('@reldens/utils');
-
-class SystemVariablesProvider
-{
-
-    constructor(props)
-    {
-        this.defaultDomain = sc.get(props, 'defaultDomain', 'default');
-        this.projectRoot = sc.get(props, 'projectRoot', './');
-        this.publicPath = sc.get(props, 'publicPath', './public');
-    }
-
-    buildSystemVariables(req, route, domain)
-    {
-        let currentRequest = this.buildCurrentRequestData(req, domain);
-        let currentRoute = this.buildCurrentRouteData(route);
-        let currentDomain = this.buildCurrentDomainData(domain);
-        let systemInfo = this.buildSystemInfo();
-        return {
-            currentRequest,
-            currentRoute,
-            currentDomain,
-            systemInfo
-        };
-    }
-
-    buildCurrentRequestData(req, domain)
-    {
-        if(!req){
-            return {};
-        }
-        let protocol = sc.get(req, 'protocol', 'http');
-        let host = req.get('host') || 'localhost';
-        let originalUrl = sc.get(req, 'originalUrl', sc.get(req, 'path', '/'));
-        let fullUrl = protocol+'://'+host+originalUrl;
-        return {
-            method: sc.get(req, 'method', 'GET'),
-            path: sc.get(req, 'path', '/'),
-            originalUrl,
-            fullUrl,
-            protocol,
-            host,
-            domain: domain || host.split(':')[0],
-            query: sc.get(req, 'query', {}),
-            params: sc.get(req, 'params', {}),
-            headers: sc.get(req, 'headers', {}),
-            userAgent: req.get('user-agent') || '',
-            ip: sc.get(req, 'ip', ''),
-            baseUrl: protocol+'://'+host,
-            timestamp: sc.getCurrentDate(),
-            isSecure: 'https' === protocol
-        };
-    }
-
-    buildCurrentRouteData(route)
-    {
-        if(!route){
-            return null;
-        }
-        return {
-            id: sc.get(route, 'id', null),
-            path: sc.get(route, 'path', ''),
-            router: sc.get(route, 'router', ''),
-            domain: sc.get(route, 'domain', null),
-            enabled: sc.get(route, 'enabled', false),
-            title: sc.get(route, 'title', ''),
-            template: sc.get(route, 'template', ''),
-            layout: sc.get(route, 'layout', ''),
-            meta_title: sc.get(route, 'meta_title', ''),
-            meta_description: sc.get(route, 'meta_description', ''),
-            sort_order: sc.get(route, 'sort_order', 0)
-        };
-    }
-
-    buildCurrentDomainData(domain)
-    {
-        return {
-            current: domain || this.defaultDomain,
-            default: this.defaultDomain,
-            resolved: domain || this.defaultDomain
-        };
-    }
-
-    buildSystemInfo()
-    {
-        let date = new Date();
-        return {
-            projectRoot: this.projectRoot,
-            publicPath: this.publicPath,
-            nodeVersion: process.version,
-            platform: process.platform,
-            environment: process.env.NODE_ENV || 'development',
-            timestamp: sc.getCurrentDate(),
-            uptime: process.uptime(),
-            currentDate: sc.formatDate(date),
-            currentYear: sc.formatDate(date, 'Y')
-        };
-    }
-
-}
-
-module.exports.SystemVariablesProvider = SystemVariablesProvider;
+/**
+ *
+ * Reldens - CMS - SystemVariablesProvider
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class SystemVariablesProvider
+{
+
+    constructor(props)
+    {
+        this.defaultDomain = sc.get(props, 'defaultDomain', 'default');
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.publicPath = sc.get(props, 'publicPath', './public');
+        this.domainPublicUrlMapping = sc.get(props, 'domainPublicUrlMapping', {});
+        this.defaultPublicUrl = sc.get(props, 'defaultPublicUrl', '');
+    }
+
+    buildSystemVariables(req, route, domain)
+    {
+        let currentRequest = this.buildCurrentRequestData(req, domain);
+        let currentRoute = this.buildCurrentRouteData(route);
+        let currentDomain = this.buildCurrentDomainData(domain);
+        let systemInfo = this.buildSystemInfo();
+        return {
+            currentRequest,
+            currentRoute,
+            currentDomain,
+            systemInfo
+        };
+    }
+
+    buildCurrentRequestData(req, domain)
+    {
+        if(!req){
+            return {};
+        }
+        let protocol = sc.get(req, 'protocol', 'http');
+        let host = req.get('host') || 'localhost';
+        let originalUrl = sc.get(req, 'originalUrl', sc.get(req, 'path', '/'));
+        let baseUrl = protocol+'://'+host;
+        let publicUrl = baseUrl;
+        let customPublicUrl = req.get('x-public-url');
+        if(customPublicUrl){
+            publicUrl = customPublicUrl;
+        }
+        if(!customPublicUrl && domain && sc.hasOwn(this.domainPublicUrlMapping, domain)){
+            publicUrl = this.domainPublicUrlMapping[domain];
+        }
+        if(publicUrl === baseUrl && '' !== this.defaultPublicUrl){
+            publicUrl = this.defaultPublicUrl;
+        }
+        if('' === baseUrl && '' !== this.defaultPublicUrl){
+            baseUrl = this.defaultPublicUrl;
+        }
+        let fullUrl = protocol+'://'+host+originalUrl;
+        return {
+            method: sc.get(req, 'method', 'GET'),
+            path: sc.get(req, 'path', '/'),
+            originalUrl,
+            fullUrl,
+            protocol,
+            host,
+            domain: domain || host.split(':')[0],
+            query: sc.get(req, 'query', {}),
+            params: sc.get(req, 'params', {}),
+            headers: sc.get(req, 'headers', {}),
+            userAgent: req.get('user-agent') || '',
+            ip: sc.get(req, 'ip', ''),
+            baseUrl,
+            publicUrl,
+            defaultPublicUrl: this.defaultPublicUrl,
+            timestamp: sc.getCurrentDate(),
+            isSecure: 'https' === protocol
+        };
+    }
+
+    buildCurrentRouteData(route)
+    {
+        if(!route){
+            return null;
+        }
+        return {
+            id: sc.get(route, 'id', null),
+            path: sc.get(route, 'path', ''),
+            router: sc.get(route, 'router', ''),
+            domain: sc.get(route, 'domain', null),
+            enabled: sc.get(route, 'enabled', false),
+            title: sc.get(route, 'title', ''),
+            template: sc.get(route, 'template', ''),
+            layout: sc.get(route, 'layout', ''),
+            meta_title: sc.get(route, 'meta_title', ''),
+            meta_description: sc.get(route, 'meta_description', ''),
+            sort_order: sc.get(route, 'sort_order', 0)
+        };
+    }
+
+    buildCurrentDomainData(domain)
+    {
+        return {
+            current: domain || this.defaultDomain,
+            default: this.defaultDomain,
+            resolved: domain || this.defaultDomain
+        };
+    }
+
+    buildSystemInfo()
+    {
+        let date = new Date();
+        return {
+            projectRoot: this.projectRoot,
+            publicPath: this.publicPath,
+            nodeVersion: process.version,
+            platform: process.platform,
+            environment: process.env.NODE_ENV || 'development',
+            timestamp: sc.getCurrentDate(),
+            uptime: process.uptime(),
+            currentDate: sc.formatDate(date),
+            currentYear: sc.formatDate(date, 'Y')
+        };
+    }
+
+}
+
+module.exports.SystemVariablesProvider = SystemVariablesProvider;

package/lib/template-engine/url-transformer.js

@@ -1,41 +1,41 @@
-/**
- *
- * Reldens - CMS - UrlTransformer
- *
- */
-
-const { sc } = require('@reldens/utils');
-
-class UrlTransformer
-{
-
-    async transform(template, domain, req, systemVariables)
-    {
-        if(!template){
-            return template;
-        }
-        let currentRequest = sc.get(systemVariables, 'currentRequest', {});
-        let urlPattern = /\[url\(([^)]+)\)\]/g;
-        let matches = [...template.matchAll(urlPattern)];
-        for(let i = matches.length - 1; i >= 0; i--){
-            let match = matches[i];
-            let urlPath = match[1].replace(/['"]/g, '');
-            let absoluteUrl = this.buildAbsoluteUrl(urlPath, currentRequest);
-            template = template.substring(0, match.index) +
-                absoluteUrl +
-                template.substring(match.index + match[0].length);
-        }
-        return template;
-    }
-
-    buildAbsoluteUrl(relativePath, currentRequest)
-    {
-        if(!relativePath || relativePath.startsWith('http')){
-            return relativePath;
-        }
-        return sc.get(currentRequest, 'baseUrl', '') + relativePath;
-    }
-
-}
-
-module.exports.UrlTransformer = UrlTransformer;
+/**
+ *
+ * Reldens - CMS - UrlTransformer
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class UrlTransformer
+{
+
+    async transform(template, domain, req, systemVariables)
+    {
+        if(!template){
+            return template;
+        }
+        let currentRequest = sc.get(systemVariables, 'currentRequest', {});
+        let urlPattern = /\[url\(([^)]+)\)\]/g;
+        let matches = [...template.matchAll(urlPattern)];
+        for(let i = matches.length - 1; i >= 0; i--){
+            let match = matches[i];
+            let urlPath = match[1].replace(/['"]/g, '');
+            let absoluteUrl = this.buildAbsoluteUrl(urlPath, currentRequest);
+            template = template.substring(0, match.index) +
+                absoluteUrl +
+                template.substring(match.index + match[0].length);
+        }
+        return template;
+    }
+
+    buildAbsoluteUrl(relativePath, currentRequest)
+    {
+        if(!relativePath || relativePath.startsWith('http')){
+            return relativePath;
+        }
+        return sc.get(currentRequest, 'publicUrl', '') + relativePath;
+    }
+
+}
+
+module.exports.UrlTransformer = UrlTransformer;