@reldens/cms 0.20.0 → 0.23.0

package/lib/dynamic-form-renderer.js

@@ -0,0 +1,228 @@
+/**
+ *
+ * Reldens - CMS - DynamicFormRenderer
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+
+class DynamicFormRenderer
+{
+
+    constructor(props)
+    {
+        this.renderEngine = sc.get(props, 'renderEngine', false);
+        this.getPartials = sc.get(props, 'getPartials', false);
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.templatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
+        this.defaultDomain = sc.get(props, 'defaultDomain', 'default');
+        this.loadedTemplates = {};
+        this.events = sc.get(props, 'events', false);
+        if(!this.events){
+            Logger.error('EventsManager not provided to DynamicFormRenderer - forms functionality disabled');
+            this.isDisabled = true;
+        }
+    }
+
+    async renderForm(formConfig, fieldsToRender, domain, req, attributes = {}, systemVariables = {}, enhancedData = {})
+    {
+        if(this.isDisabled){
+            return '';
+        }
+        await this.events.emit('reldens.dynamicFormRenderer.beforeFieldsRender', {
+            formConfig,
+            fieldsToRender,
+            domain,
+            req,
+            attributes,
+            systemVariables,
+            enhancedData
+        });
+        let formFields = await this.renderFormFields(fieldsToRender, domain, req);
+        await this.events.emit('reldens.dynamicFormRenderer.afterFieldsRender', {
+            formConfig,
+            fieldsToRender,
+            formFields,
+            domain,
+            req,
+            attributes,
+            systemVariables,
+            enhancedData
+        });
+        let formTemplate = await this.loadFormTemplate('form', domain);
+        if(!formTemplate){
+            Logger.error('Form template not found');
+            return '';
+        }
+        let messageData = this.parseFormMessages(req, attributes);
+        return this.renderEngine.render(formTemplate, Object.assign({}, enhancedData, {
+            formKey: formConfig.form_key,
+            formFields,
+            submitUrl: sc.get(attributes, 'submitUrl', '/dynamic-form'),
+            successRedirect: sc.get(attributes, 'successRedirect', '/'),
+            errorRedirect: sc.get(attributes, 'errorRedirect', '/'),
+            honeypotFieldName: sc.get(attributes, 'honeypotFieldName', 'website_url'),
+            submitButtonText: sc.get(attributes, 'submitButtonText', 'Submit'),
+            cssClass: sc.get(attributes, 'cssClass', 'dynamic-form'),
+            showSuccessMessage: messageData.showSuccessMessage,
+            successMessage: messageData.successMessage,
+            showErrorMessage: messageData.showErrorMessage,
+            errorMessage: messageData.errorMessage,
+            systemVariables
+        }), this.getPartialsForDomain(domain));
+    }
+
+    parseFormMessages(req, attributes)
+    {
+        let queryParams = sc.get(req, 'query', {});
+        let formSuccess = sc.get(queryParams, 'form-success', '');
+        let formError = sc.get(queryParams, 'form-error', '');
+        let formKey = sc.get(queryParams, 'form-key', '');
+        let showSuccessMessage = '1' === formSuccess && '' !== formKey;
+        let showErrorMessage = '' !== formError && '' !== formKey;
+        let successMessage = sc.get(attributes, 'successMessage', 'Form submitted successfully!');
+        let errorMessage = sc.get(attributes, 'errorMessage', formError || 'There was an error submitting the form.');
+        return {
+            showSuccessMessage,
+            successMessage,
+            showErrorMessage,
+            errorMessage
+        };
+    }
+
+    async renderFormFields(fieldsToRender, domain, req, submittedValues = {}, errors = {})
+    {
+        if(!sc.isArray(fieldsToRender) || 0 === fieldsToRender.length){
+            return '';
+        }
+        let renderedFields = '';
+        for(let field of fieldsToRender){
+            if(!sc.isObject(field)){
+                continue;
+            }
+            let fieldHtml = await this.renderFormField(field, domain, submittedValues, errors);
+            if(fieldHtml){
+                renderedFields += fieldHtml;
+            }
+        }
+        return renderedFields;
+    }
+
+    async renderFormField(field, domain, submittedValues = {}, errors = {})
+    {
+        let fieldType = sc.get(field, 'type', 'text');
+        let fieldTemplate = await this.loadFormTemplate('field_'+fieldType, domain);
+        if(!fieldTemplate){
+            fieldTemplate = await this.loadFormTemplate('field_text', domain);
+        }
+        if(!fieldTemplate){
+            Logger.error('Field template not found for type: '+fieldType);
+            return '';
+        }
+        return this.renderEngine.render(
+            fieldTemplate,
+            this.buildFieldTemplateData(field, submittedValues, errors),
+            this.getPartialsForDomain(domain)
+        );
+    }
+
+    buildFieldTemplateData(field, submittedValues = {}, errors = {})
+    {
+        let fieldName = sc.get(field, 'name', '');
+        let fieldType = sc.get(field, 'type', 'text');
+        let fieldLabel = sc.get(field, 'label', fieldName);
+        let fieldValue = sc.get(submittedValues, fieldName, sc.get(field, 'defaultValue', ''));
+        let isRequired = sc.get(field, 'required', false);
+        let fieldError = sc.get(errors, fieldName, '');
+        let options = sc.get(field, 'options', []);
+        if(sc.isArray(options)){
+            options = options.map(option => {
+                if(sc.isObject(option)){
+                    return {
+                        value: sc.get(option, 'value', ''),
+                        label: sc.get(option, 'label', sc.get(option, 'value', '')),
+                        selected: sc.get(option, 'value', '') === fieldValue
+                    };
+                }
+                return {
+                    value: option,
+                    label: option,
+                    selected: option === fieldValue
+                };
+            });
+        }
+        return {
+            field,
+            fieldName,
+            fieldType,
+            fieldLabel,
+            fieldValue,
+            isRequired,
+            fieldError,
+            hasError: '' !== fieldError,
+            requiredClass: isRequired ? 'required' : '',
+            errorClass: '' !== fieldError ? 'error' : '',
+            options,
+            placeholder: sc.get(field, 'placeholder', ''),
+            helpText: sc.get(field, 'helpText', ''),
+            maxLength: sc.get(field, 'maxLength', ''),
+            pattern: sc.get(field, 'pattern', ''),
+            min: sc.get(field, 'min', ''),
+            max: sc.get(field, 'max', ''),
+            step: sc.get(field, 'step', '')
+        };
+    }
+
+    async loadFormTemplate(templateName, domain)
+    {
+        let cacheKey = templateName+'_'+domain;
+        if(sc.hasOwn(this.loadedTemplates, cacheKey)){
+            return this.loadedTemplates[cacheKey];
+        }
+        let templatePath = this.findFormTemplate(templateName, domain);
+        if(!templatePath){
+            Logger.warning('Form template not found: '+templateName+' for domain: '+domain);
+            return false;
+        }
+        let templateContent = await FileHandler.readFile(templatePath);
+        if(!templateContent){
+            Logger.error('Failed to read form template: '+templatePath);
+            return false;
+        }
+        this.loadedTemplates[cacheKey] = templateContent;
+        return templateContent;
+    }
+
+    findFormTemplate(templateName, domain)
+    {
+        let filename = templateName+'.html';
+        let domainTemplatePath = FileHandler.joinPaths(this.templatesPath, 'domains', domain, 'cms_forms', filename);
+        if(FileHandler.exists(domainTemplatePath)){
+            return domainTemplatePath;
+        }
+        if(this.defaultDomain && domain !== this.defaultDomain){
+            let defaultDomainPath = FileHandler.joinPaths(this.templatesPath, 'domains', this.defaultDomain, 'cms_forms', filename);
+            if(FileHandler.exists(defaultDomainPath)){
+                return defaultDomainPath;
+            }
+        }
+        let rootTemplatePath = FileHandler.joinPaths(this.templatesPath, 'cms_forms', filename);
+        if(FileHandler.exists(rootTemplatePath)){
+            return rootTemplatePath;
+        }
+        return false;
+    }
+
+    getPartialsForDomain(domain)
+    {
+        if(!this.getPartials){
+            Logger.error('getPartials function not provided to DynamicFormRenderer');
+            return {};
+        }
+        return this.getPartials(domain);
+    }
+
+}
+
+module.exports.DynamicFormRenderer = DynamicFormRenderer;

package/lib/dynamic-form-request-handler.js

@@ -0,0 +1,135 @@
+/**
+ *
+ * Reldens - CMS - DynamicFormRequestHandler
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class DynamicFormRequestHandler
+{
+
+    constructor(props)
+    {
+        this.dynamicForm = sc.get(props, 'dynamicForm', false);
+        this.contentRenderer = sc.get(props, 'contentRenderer', false);
+        this.requestProcessor = sc.get(props, 'requestProcessor', false);
+        this.cacheManager = sc.get(props, 'cacheManager', false);
+        this.enableJsonResponse = sc.get(props, 'enableJsonResponse', false);
+        this.events = sc.get(props, 'events', false);
+        if(!this.events){
+            Logger.error('EventsManager not provided to DynamicFormRequestHandler - forms functionality disabled');
+            this.isDisabled = true;
+        }
+    }
+
+    async handleFormSubmission(req, res)
+    {
+        if(this.isDisabled){
+            return this.handleBadRequest(res, 'Forms functionality disabled');
+        }
+        try {
+            let formKey = sc.get(req.body, 'formKey', '');
+            let submittedValues = sc.get(req.body, 'submittedValues', {});
+            if(!formKey || !submittedValues){
+                return this.handleBadRequest(res, 'Missing formKey or submittedValues');
+            }
+            await this.events.emit('reldens.dynamicFormRequestHandler.beforeValidation', {
+                formKey,
+                submittedValues,
+                req,
+                res
+            });
+            let validation = await this.dynamicForm.validateFormSubmission(formKey, submittedValues, req);
+            if(!validation.isValid){
+                return this.handleValidationError(req, res, validation.error, formKey);
+            }
+            let preparedValues = this.dynamicForm.prepareSubmittedValues(
+                submittedValues,
+                validation.formConfig.fields_schema
+            );
+            await this.events.emit('reldens.dynamicFormRequestHandler.beforeSave', {
+                formKey,
+                preparedValues,
+                formConfig: validation.formConfig,
+                req,
+                res
+            });
+            let submissionResult = await this.dynamicForm.saveFormSubmission(
+                validation.formConfig,
+                preparedValues
+            );
+            if(!submissionResult){
+                return this.handleValidationError(req, res, 'Failed to save form submission', formKey);
+            }
+            await this.events.emit('reldens.dynamicFormRequestHandler.afterSave', {
+                formKey,
+                submissionResult,
+                formConfig: validation.formConfig,
+                req,
+                res
+            });
+            return this.handleSuccessResponse(req, res, formKey, submissionResult);
+        } catch(error) {
+            Logger.error('Form submission handling error: '+error.message);
+            return this.handleBadRequest(res, 'Internal server error');
+        }
+    }
+
+    handleBadRequest(res, message)
+    {
+        if(this.enableJsonResponse){
+            return res.status(400).json({
+                success: false,
+                error: message
+            });
+        }
+        return res.status(400).send('Bad Request: '+message);
+    }
+
+    handleValidationError(req, res, error, formKey)
+    {
+        if(this.enableJsonResponse){
+            return res.status(400).json({
+                success: false,
+                error: error,
+                formKey: formKey
+            });
+        }
+        return res.redirect(this.buildErrorRedirectPath(req, error, formKey));
+    }
+
+    handleSuccessResponse(req, res, formKey, submissionResult)
+    {
+        if(this.enableJsonResponse){
+            return res.json({
+                success: true,
+                message: 'Form submitted successfully',
+                formKey: formKey,
+                submissionId: submissionResult.id
+            });
+        }
+        return res.redirect(this.buildSuccessRedirectPath(sc.get(req.body, 'successRedirect', '/'), formKey));
+    }
+
+    buildErrorRedirectPath(req, error, formKey)
+    {
+        let baseRedirect = sc.get(req.body, 'errorRedirect', '/');
+        let finalRedirect = sc.get(req.headers, 'referer', baseRedirect) || baseRedirect;
+        return finalRedirect
+            +(finalRedirect.includes('?') ? '&' : '?')
+            +'form-error='+encodeURIComponent(error)
+            +'&form-key='+encodeURIComponent(formKey);
+    }
+
+    buildSuccessRedirectPath(successRedirect, formKey)
+    {
+        return successRedirect
+            +(successRedirect.includes('?') ? '&' : '?')
+            +'form-success=1'
+            +'&form-key='+encodeURIComponent(formKey);
+    }
+
+}
+
+module.exports.DynamicFormRequestHandler = DynamicFormRequestHandler;

package/lib/dynamic-form.js

@@ -0,0 +1,310 @@
+/**
+ *
+ * Reldens - CMS - DynamicForm
+ *
+ */
+
+const { SchemaValidator, Logger, sc } = require('@reldens/utils');
+
+class DynamicForm
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.honeypotFieldName = sc.get(props, 'honeypotFieldName', 'website_url');
+        this.allowedOrigins = sc.get(props, 'allowedOrigins', []);
+        this.rateLimitCache = new Map();
+        this.rateLimitWindow = sc.get(props, 'rateLimitWindow', 300000);
+        this.rateLimitMax = sc.get(props, 'rateLimitMax', 5);
+        this.events = sc.get(props, 'events', false);
+        if(!this.events){
+            Logger.error('EventsManager not provided to DynamicForm - forms functionality disabled');
+            this.isDisabled = true;
+        }
+    }
+
+    async validateFormSubmission(formKey, submittedValues, req)
+    {
+        if(this.isDisabled){
+            return {isValid: false, error: 'Forms functionality disabled'};
+        }
+        if(!formKey || !submittedValues){
+            return {isValid: false, error: 'Missing formKey or submittedValues'};
+        }
+        if(!sc.isObject(submittedValues)){
+            return {isValid: false, error: 'Invalid submittedValues format'};
+        }
+        let formConfig = await this.getFormConfig(formKey);
+        if(!formConfig){
+            return {isValid: false, error: 'Form not found or disabled'};
+        }
+        await this.events.emit('reldens.dynamicForm.beforeValidation', {
+            formKey,
+            formConfig,
+            submittedValues,
+            req
+        });
+        let originValidation = this.validateOrigin(req);
+        if(!originValidation.isValid){
+            return originValidation;
+        }
+        let honeypotValidation = this.validateHoneypot(submittedValues);
+        if(!honeypotValidation.isValid){
+            return honeypotValidation;
+        }
+        let rateLimitValidation = this.validateRateLimit(req);
+        if(!rateLimitValidation.isValid){
+            return rateLimitValidation;
+        }
+        let fieldsValidation = this.validateFields(formConfig.fields_schema, submittedValues);
+        if(!fieldsValidation.isValid){
+            return fieldsValidation;
+        }
+        await this.events.emit('reldens.dynamicForm.afterValidation', {
+            formKey,
+            formConfig,
+            submittedValues,
+            req,
+            validationResult: {isValid: true, formConfig}
+        });
+        return {isValid: true, formConfig};
+    }
+
+    async getFormConfig(formKey)
+    {
+        let formsEntity = this.dataServer.getEntity('cmsForms');
+        if(!formsEntity){
+            Logger.error('Forms entity not found');
+            return false;
+        }
+        let form = await formsEntity.loadOneBy('form_key', formKey);
+        if(!form || !form.enabled){
+            return false;
+        }
+        return form;
+    }
+
+    validateHoneypot(submittedValues)
+    {
+        let honeypotValue = sc.get(submittedValues, this.honeypotFieldName, '');
+        if('' !== honeypotValue){
+            Logger.warning('Honeypot field filled, potential bot submission');
+            return {isValid: false, error: 'Invalid submission'};
+        }
+        return {isValid: true};
+    }
+
+    validateOrigin(req)
+    {
+        if(0 === this.allowedOrigins.length){
+            return {isValid: true};
+        }
+        let origin = sc.get(req.headers, 'origin', '');
+        let referer = sc.get(req.headers, 'referer', '');
+        let host = sc.get(req.headers, 'host', '');
+        let isValidOrigin = false;
+        for(let allowedOrigin of this.allowedOrigins){
+            if(origin.includes(allowedOrigin) || referer.includes(allowedOrigin) || host.includes(allowedOrigin)){
+                isValidOrigin = true;
+                break;
+            }
+        }
+        if(!isValidOrigin){
+            Logger.warning('Invalid form submission origin: '+origin+' / '+referer+' / '+host);
+            return {isValid: false, error: 'Invalid request origin'};
+        }
+        return {isValid: true};
+    }
+
+    validateRateLimit(req)
+    {
+        let clientIp = this.getClientIp(req);
+        let now = Date.now();
+        let clientLimits = this.rateLimitCache.get(clientIp) || {submissions: [], firstSubmission: now};
+        clientLimits.submissions = clientLimits.submissions.filter(time => now - time < this.rateLimitWindow);
+        if(clientLimits.submissions.length >= this.rateLimitMax){
+            Logger.warning('Rate limit exceeded for IP: '+clientIp);
+            return {isValid: false, error: 'Too many submissions, please try again later'};
+        }
+        clientLimits.submissions.push(now);
+        this.rateLimitCache.set(clientIp, clientLimits);
+        return {isValid: true};
+    }
+
+    getClientIp(req)
+    {
+        return sc.get(req.headers, 'x-forwarded-for', sc.get(req.connection, 'remoteAddress', 'unknown')).split(',')[0].trim();
+    }
+
+    validateFields(fieldsSchema, submittedValues)
+    {
+        let parsedSchema = sc.isString(fieldsSchema) ? sc.toJson(fieldsSchema) : fieldsSchema;
+        if(!sc.isArray(parsedSchema)){
+            Logger.error('Invalid fields schema format');
+            return {isValid: false, error: 'Invalid form configuration'};
+        }
+        let schemaForValidator = {};
+        let missingFields = [];
+        for(let field of parsedSchema){
+            if(!sc.isObject(field)){
+                continue;
+            }
+            let fieldName = sc.get(field, 'name', '');
+            let fieldType = sc.get(field, 'type', 'text');
+            let isRequired = sc.get(field, 'required', false);
+            if('' === fieldName){
+                continue;
+            }
+            let validationSchema = this.buildValidationSchema(field, fieldType);
+            validationSchema.required = isRequired;
+            schemaForValidator[fieldName] = validationSchema;
+            if(isRequired){
+                let fieldValue = sc.get(submittedValues, fieldName, '');
+                if('' === fieldValue || null === fieldValue || undefined === fieldValue){
+                    let fieldLabel = sc.get(field, 'label', fieldName);
+                    missingFields.push(fieldLabel);
+                }
+            }
+        }
+        if(0 < missingFields.length){
+            return {
+                isValid: false,
+                error: 'Required fields missing: '+missingFields.join(', '),
+                missingFields
+            };
+        }
+        let validator = new SchemaValidator(schemaForValidator);
+        if(!validator.validate(submittedValues)){
+            return {isValid: false, error: 'Invalid field values provided'};
+        }
+        return {isValid: true};
+    }
+
+    buildValidationSchema(field, fieldType)
+    {
+        let schema = {type: 'string'};
+        let minLength = sc.get(field, 'minLength', 0);
+        let maxLength = sc.get(field, 'maxLength', 0);
+        let pattern = sc.get(field, 'pattern', '');
+        let min = sc.get(field, 'min', '');
+        let max = sc.get(field, 'max', '');
+        if('number' === fieldType){
+            schema.type = 'number';
+            if('' !== min && sc.isNumber(Number(min))){
+                schema.min = Number(min);
+            }
+            if('' !== max && sc.isNumber(Number(max))){
+                schema.max = Number(max);
+            }
+        }
+        if('email' === fieldType){
+            schema.custom = (value) => {
+                if(!value){
+                    return true;
+                }
+                let emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                return emailPattern.test(value);
+            };
+        }
+        if(0 < minLength){
+            schema.min = minLength;
+        }
+        if(0 < maxLength){
+            schema.max = maxLength;
+        }
+        if('' !== pattern){
+            try {
+                schema.pattern = new RegExp(pattern);
+            } catch(error) {
+                Logger.warning('Invalid field pattern: '+pattern+' for field: '+sc.get(field, 'name', ''));
+            }
+        }
+        let options = sc.get(field, 'options', []);
+        if(sc.isArray(options) && 0 < options.length){
+            schema.enum = options.map(option => {
+                return sc.isObject(option) ? sc.get(option, 'value', '') : option;
+            });
+        }
+        return schema;
+    }
+
+    prepareSubmittedValues(submittedValues, fieldsSchema)
+    {
+        let parsedSchema = sc.isString(fieldsSchema) ? sc.toJson(fieldsSchema) : fieldsSchema;
+        if(!sc.isArray(parsedSchema)){
+            return submittedValues;
+        }
+        let prepared = {};
+        for(let field of parsedSchema){
+            if(!sc.isObject(field)){
+                continue;
+            }
+            let fieldName = sc.get(field, 'name', '');
+            let fieldType = sc.get(field, 'type', 'text');
+            let fieldValue = sc.get(submittedValues, fieldName, '');
+            if('' === fieldName){
+                continue;
+            }
+            prepared[fieldName] = this.normalizeFieldValue(fieldValue, fieldType, field);
+        }
+        return prepared;
+    }
+
+    normalizeFieldValue(value, type, field = {})
+    {
+        if(!value){
+            return '';
+        }
+        let stringValue = String(value);
+        if('email' === type){
+            stringValue = stringValue.toLowerCase().trim();
+        }
+        if('number' === type){
+            let numberValue = parseFloat(stringValue);
+            return isNaN(numberValue) ? '' : numberValue;
+        }
+        let maxLength = sc.get(field, 'maxLength', 0);
+        if(0 < maxLength){
+            stringValue = stringValue.substring(0, maxLength);
+        }
+        return stringValue;
+    }
+
+    async saveFormSubmission(formConfig, preparedValues)
+    {
+        let submissionsEntity = this.dataServer.getEntity('cmsFormsSubmitted');
+        if(!submissionsEntity){
+            Logger.error('Forms submissions entity not found');
+            return false;
+        }
+        await this.events.emit('reldens.dynamicForm.beforeSave', {
+            formConfig,
+            preparedValues
+        });
+        try {
+            let submissionData = {
+                form_id: formConfig.id,
+                submitted_values: JSON.stringify(preparedValues)
+            };
+            let result = await submissionsEntity.create(submissionData);
+            if(!result){
+                Logger.error('Failed to save form submission');
+                return false;
+            }
+            await this.events.emit('reldens.dynamicForm.afterSave', {
+                formConfig,
+                preparedValues,
+                result
+            });
+            Logger.info('Form submission saved successfully for form: '+formConfig.form_key);
+            return result;
+        } catch(error) {
+            Logger.error('Error saving form submission: '+error.message);
+            return false;
+        }
+    }
+
+}
+
+module.exports.DynamicForm = DynamicForm;