@reldens/cms 0.19.0 → 0.21.0

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

@@ -13,9 +13,10 @@ class PartialsTransformer
     {
         this.renderEngine = sc.get(props, 'renderEngine', false);
         this.getPartials = sc.get(props, 'getPartials', false);
+        this.processAllTemplateFunctions = sc.get(props, 'processAllTemplateFunctions', false);
     }
 
-    async transform(template, domain)
+    async transform(template, domain, req, systemVariables, enhancedData = {})
     {
         let processedTemplate = template;
         let partialTags = this.findAllPartialTags(template);
@@ -27,11 +28,13 @@ class PartialsTransformer
                 processedTemplate = processedTemplate.substring(0, tag.start)+''+processedTemplate.substring(tag.end);
                 continue;
             }
-            let wrapperTemplate = '{{#vars}}{{> ' + tag.name + '}}{{/vars}}';
-            let renderData = { vars: tag.attributes };
-            let partials = {[tag.name]: partialContent};
+            if(this.processAllTemplateFunctions){
+                partialContent = await this.processAllTemplateFunctions(partialContent, domain, req, systemVariables, enhancedData);
+            }
+            let partialData = Object.assign({}, enhancedData, tag.attributes);
+            let renderedPartial = this.renderEngine.render(partialContent, partialData, {});
             processedTemplate = processedTemplate.substring(0, tag.start) +
-                this.renderEngine.render(wrapperTemplate, renderData, partials) +
+                renderedPartial +
                 processedTemplate.substring(tag.end);
         }
         return processedTemplate;

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

@@ -0,0 +1,108 @@
+/**
+ *
+ * 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;

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

@@ -0,0 +1,98 @@
+/**
+ *
+ * Reldens - CMS - TranslateTransformer
+ *
+ */
+
+const { TranslationService } = require('./translation-service');
+const { FileHandler } = require('@reldens/server-utils');
+const { sc } = require('@reldens/utils');
+
+class TranslateTransformer
+{
+
+    constructor(props)
+    {
+        let projectRoot = sc.get(props, 'projectRoot', './');
+        let translationsPath = FileHandler.joinPaths(projectRoot, 'translations');
+        this.translationService = new TranslationService({
+            translationsPath,
+            defaultLocale: sc.get(props, 'defaultLocale', 'en'),
+            fallbackLocale: sc.get(props, 'fallbackLocale', 'en')
+        });
+    }
+
+    async transform(template, domain, req, systemVariables)
+    {
+        if(!template){
+            return template;
+        }
+        let currentLocale = this.extractLocaleFromSystemVariables(systemVariables);
+        let translatePattern = /\[(?:translate|t)\(([^)]+)\)\]/g;
+        let matches = [...template.matchAll(translatePattern)];
+        for(let i = matches.length - 1; i >= 0; i--){
+            let match = matches[i];
+            let args = this.parseTranslateArgs(match[1]);
+            let translatedText = await this.translationService.translate(
+                args.key,
+                currentLocale,
+                args.defaultValue,
+                args.interpolations
+            );
+            template = template.substring(0, match.index) +
+                translatedText +
+                template.substring(match.index + match[0].length);
+        }
+        return template;
+    }
+
+    parseTranslateArgs(argsString)
+    {
+        let args = argsString.split(',').map(arg => arg.trim().replace(/['"]/g, ''));
+        return {
+            key: args[0] || '',
+            defaultValue: args[1] || '',
+            interpolations: this.parseInterpolations(args[2])
+        };
+    }
+
+    parseInterpolations(interpolationsStr)
+    {
+        if(!interpolationsStr){
+            return {};
+        }
+        let interpolations = {};
+        let pairs = interpolationsStr.replace(/[{}]/g, '').split(',');
+        for(let pair of pairs){
+            let keyValue = pair.split(':');
+            if(2 === keyValue.length){
+                interpolations[keyValue[0].trim()] = keyValue[1].trim();
+            }
+        }
+        return interpolations;
+    }
+
+    extractLocaleFromSystemVariables(systemVariables)
+    {
+        let currentRequest = sc.get(systemVariables, 'currentRequest', {});
+        let headers = sc.get(currentRequest, 'headers', {});
+        let acceptLanguage = sc.get(headers, 'accept-language', '');
+        if(acceptLanguage){
+            let primaryLanguage = acceptLanguage.split(',')[0];
+            if(primaryLanguage && primaryLanguage.includes('-')){
+                return primaryLanguage.split('-')[0];
+            }
+            if(primaryLanguage){
+                return primaryLanguage;
+            }
+        }
+        let locale = sc.get(currentRequest, 'query', {}).locale;
+        if(locale){
+            return locale;
+        }
+        return this.translationService.defaultLocale;
+    }
+
+}
+
+module.exports.TranslateTransformer = TranslateTransformer;

package/lib/template-engine/translation-service.js

@@ -0,0 +1,104 @@
+/**
+ *
+ * Reldens - CMS - TranslationService
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+
+class TranslationService
+{
+
+    constructor(props)
+    {
+        this.translationsPath = sc.get(props, 'translationsPath', './translations');
+        this.defaultLocale = sc.get(props, 'defaultLocale', 'en');
+        this.fallbackLocale = sc.get(props, 'fallbackLocale', 'en');
+        this.translations = new Map();
+        this.loadedLocales = new Set();
+    }
+
+    async loadTranslations(locale)
+    {
+        if(this.loadedLocales.has(locale)){
+            return true;
+        }
+        let translationFile = FileHandler.joinPaths(this.translationsPath, locale + '.json');
+        if(!FileHandler.exists(translationFile)){
+            if(locale !== this.fallbackLocale){
+                Logger.warning('Translation file not found for locale: '+locale+', loading fallback');
+                return await this.loadTranslations(this.fallbackLocale);
+            }
+            Logger.warning('Translation file not found: '+translationFile);
+            return false;
+        }
+        let translationContent = FileHandler.readFile(translationFile);
+        if(!translationContent){
+            Logger.error('Failed to read translation file: '+translationFile);
+            return false;
+        }
+        let translationData = sc.toJson(translationContent, {});
+        if(!translationData){
+            Logger.error('Invalid JSON in translation file: '+translationFile);
+            return false;
+        }
+        this.translations.set(locale, translationData);
+        this.loadedLocales.add(locale);
+        return true;
+    }
+
+    async translate(key, locale, defaultValue, interpolations)
+    {
+        let targetLocale = locale || this.defaultLocale;
+        if(!this.loadedLocales.has(targetLocale)){
+            await this.loadTranslations(targetLocale);
+        }
+        let translations = this.translations.get(targetLocale);
+        let translatedText = this.getNestedTranslation(translations, key);
+        if(!translatedText && targetLocale !== this.fallbackLocale){
+            if(!this.loadedLocales.has(this.fallbackLocale)){
+                await this.loadTranslations(this.fallbackLocale);
+            }
+            let fallbackTranslations = this.translations.get(this.fallbackLocale);
+            translatedText = this.getNestedTranslation(fallbackTranslations, key);
+        }
+        if(!translatedText){
+            translatedText = defaultValue || key;
+        }
+        if(interpolations && sc.isObject(interpolations)){
+            translatedText = this.interpolateString(translatedText, interpolations);
+        }
+        return translatedText;
+    }
+
+    getNestedTranslation(translations, key)
+    {
+        if(!translations || !key){
+            return null;
+        }
+        let keys = key.split('.');
+        let current = translations;
+        for(let keyPart of keys){
+            if(!sc.hasOwn(current, keyPart)){
+                return null;
+            }
+            current = current[keyPart];
+        }
+        return sc.isString(current) ? current : null;
+    }
+
+    interpolateString(text, interpolations)
+    {
+        let result = text;
+        for(let key of Object.keys(interpolations)){
+            let placeholder = '{' + key + '}';
+            let value = interpolations[key];
+            result = result.replace(new RegExp(sc.sanitize(placeholder), 'g'), value);
+        }
+        return result;
+    }
+
+}
+
+module.exports.TranslationService = TranslationService;

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

@@ -0,0 +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;

package/lib/template-engine.js

@@ -9,6 +9,11 @@ const { EntitiesTransformer } = require('./template-engine/entities-transformer'
 const { CollectionsTransformer } = require('./template-engine/collections-transformer');
 const { CollectionsSingleTransformer } = require('./template-engine/collections-single-transformer');
 const { PartialsTransformer } = require('./template-engine/partials-transformer');
+const { UrlTransformer } = require('./template-engine/url-transformer');
+const { AssetTransformer } = require('./template-engine/asset-transformer');
+const { DateTransformer } = require('./template-engine/date-transformer');
+const { TranslateTransformer } = require('./template-engine/translate-transformer');
+const { SystemVariablesProvider } = require('./template-engine/system-variables-provider');
 const { Logger, sc } = require('@reldens/utils');
 
 class TemplateEngine
@@ -19,7 +24,16 @@ class TemplateEngine
         this.renderEngine = sc.get(props, 'renderEngine', false);
         this.dataServer = sc.get(props, 'dataServer', false);
         this.getPartials = sc.get(props, 'getPartials', false);
+        this.events = sc.get(props, 'events', false);
+        this.defaultDomain = sc.get(props, 'defaultDomain', 'default');
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.publicPath = sc.get(props, 'publicPath', './public');
         this.jsonFieldsParser = new JsonFieldsParser({entitiesConfig: sc.get(props, 'entitiesConfig', {})});
+        this.systemVariablesProvider = new SystemVariablesProvider({
+            defaultDomain: this.defaultDomain,
+            projectRoot: this.projectRoot,
+            publicPath: this.publicPath
+        });
         this.entitiesTransformer = new EntitiesTransformer({
             dataServer: this.dataServer,
             jsonFieldsParser: this.jsonFieldsParser,
@@ -31,7 +45,8 @@ class TemplateEngine
             renderEngine: this.renderEngine,
             getPartials: this.getPartials,
             findAllPartialTags: this.findAllPartialTags.bind(this),
-            loadPartialTemplate: this.loadPartialTemplate.bind(this)
+            loadPartialTemplate: this.loadPartialTemplate.bind(this),
+            processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this)
         });
         this.collectionsTransformer = new CollectionsTransformer({
             dataServer: this.dataServer,
@@ -39,48 +54,120 @@ class TemplateEngine
             renderEngine: this.renderEngine,
             getPartials: this.getPartials,
             findAllPartialTags: this.findAllPartialTags.bind(this),
-            loadPartialTemplate: this.loadPartialTemplate.bind(this)
+            loadPartialTemplate: this.loadPartialTemplate.bind(this),
+            processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this)
         });
         this.partialsTransformer = new PartialsTransformer({
             renderEngine: this.renderEngine,
-            getPartials: this.getPartials
+            getPartials: this.getPartials,
+            processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this)
+        });
+        this.urlTransformer = new UrlTransformer();
+        this.assetTransformer = new AssetTransformer();
+        this.dateTransformer = new DateTransformer({
+            defaultFormat: sc.get(props, 'defaultDateFormat', 'Y-m-d H:i:s')
+        });
+        this.translateTransformer = new TranslateTransformer({
+            projectRoot: this.projectRoot,
+            defaultLocale: sc.get(props, 'defaultLocale', 'en'),
+            fallbackLocale: sc.get(props, 'fallbackLocale', 'en')
         });
         this.transformers = [
             this.entitiesTransformer,
             this.collectionsSingleTransformer,
             this.collectionsTransformer,
-            this.partialsTransformer
+            this.partialsTransformer,
+            this.urlTransformer,
+            this.assetTransformer,
+            this.dateTransformer,
+            this.translateTransformer
         ];
     }
 
-    async processAllTemplateFunctions(template, domain, req)
+    async processAllTemplateFunctions(template, domain, req, systemVariables, enhancedData = {})
     {
         let processedTemplate = template;
         for(let transformer of this.transformers){
-            if(sc.isFunction(transformer.transform)){
-                processedTemplate = await transformer.transform(processedTemplate, domain, req);
+            if(!transformer){
+                continue;
             }
+            if(!sc.isFunction(transformer.transform)){
+                continue;
+            }
+            processedTemplate = await transformer.transform(processedTemplate, domain, req, systemVariables, enhancedData);
         }
         return processedTemplate;
     }
 
-    async render(template, data, partials, domain, req)
+    async render(template, data, partials, domain, req, route, currentEntityData)
     {
         if(!this.renderEngine){
-            Logger.error('Render engine not provided');
+            Logger.critical('Render engine not provided');
             return '';
         }
         if(!sc.isFunction(this.renderEngine.render)){
-            Logger.error('Render engine does not contain a render method');
+            Logger.critical('Render engine does not contain a render method');
             return '';
         }
-        return this.renderEngine.render(
-            this.unescapeHtml(await this.processAllTemplateFunctions(template, domain, req)),
+        if(!this.events){
+            Logger.critical('Events manager not provided');
+            return '';
+        }
+        let systemVariables = this.systemVariablesProvider.buildSystemVariables(req, route, domain);
+        let renderContext = {
+            template,
             data,
+            partials,
+            domain,
+            req,
+            route,
+            currentEntityData
+        };
+        let eventData = {
+            variables: systemVariables,
+            renderContext
+        };
+        await this.events.emit('reldens.afterVariablesCreated', eventData);
+        let enhancedData = this.buildEnhancedRenderData(data, eventData.variables, currentEntityData);
+        let beforeProcessData = {
+            content: template,
+            variables: enhancedData,
+            renderContext
+        };
+        await this.events.emit('reldens.beforeContentProcess', beforeProcessData);
+        let processedTemplate = await this.processAllTemplateFunctions(
+            beforeProcessData.content,
+            domain,
+            req,
+            eventData.variables,
+            enhancedData
+        );
+        let afterProcessData = {
+            processedContent: processedTemplate,
+            variables: enhancedData,
+            renderContext
+        };
+        await this.events.emit('reldens.afterContentProcess', afterProcessData);
+        return this.renderEngine.render(
+            this.unescapeHtml(afterProcessData.processedContent),
+            enhancedData,
             partials
         );
     }
 
+    buildEnhancedRenderData(originalData, systemVariables, currentEntityData)
+    {
+        let enhancedData = Object.assign({}, originalData);
+        enhancedData.currentRequest = systemVariables.currentRequest;
+        enhancedData.currentRoute = systemVariables.currentRoute;
+        enhancedData.currentDomain = systemVariables.currentDomain;
+        enhancedData.systemInfo = systemVariables.systemInfo;
+        if(currentEntityData){
+            enhancedData.currentEntity = currentEntityData;
+        }
+        return enhancedData;
+    }
+
     unescapeHtml(text)
     {
         return text