@reldens/cms 0.18.0 → 0.20.0

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

@@ -0,0 +1,105 @@
+/**
+ *
+ * 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()
+    {
+        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()
+        };
+    }
+
+}
+
+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;