@reldens/cms 0.21.0 → 0.23.0

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;

package/lib/frontend.js

@@ -8,6 +8,9 @@ const { TemplateEngine } = require('./template-engine');
 const { Search } = require('./search');
 const { SearchRenderer } = require('./search-renderer');
 const { SearchRequestHandler } = require('./search-request-handler');
+const { DynamicForm } = require('./dynamic-form');
+const { DynamicFormRenderer } = require('./dynamic-form-renderer');
+const { DynamicFormRequestHandler } = require('./dynamic-form-request-handler');
 const { TemplateResolver } = require('./frontend/template-resolver');
 const { TemplateCache } = require('./frontend/template-cache');
 const { RequestProcessor } = require('./frontend/request-processor');
@@ -39,12 +42,23 @@ class Frontend
         this.cacheManager = sc.get(props, 'cacheManager', false);
         this.handleFrontendTemplateReload = sc.get(props, 'handleFrontendTemplateReload', false);
         this.searchPath = sc.get(props, 'searchPath', '/search');
+        this.dynamicFormPath = sc.get(props, 'dynamicFormPath', '/dynamic-form');
+        this.dynamicFormDisplayPath = sc.get(props, 'dynamicFormDisplayPath', '/form');
         this.searchSets = sc.get(props, 'searchSets', false);
         this.searchConfig = {dataServer: this.dataServer};
         if(this.searchSets){
             this.searchConfig.searchSets = this.searchSets;
         }
         this.search = new Search(this.searchConfig);
+        this.dynamicFormConfig = {
+            dataServer: this.dataServer,
+            allowedOrigins: sc.get(props, 'allowedOrigins', []),
+            honeypotFieldName: sc.get(props, 'honeypotFieldName', 'website_url'),
+            rateLimitWindow: sc.get(props, 'rateLimitWindow', 300000),
+            rateLimitMax: sc.get(props, 'rateLimitMax', 5),
+            events: this.events
+        };
+        this.dynamicForm = new DynamicForm(this.dynamicFormConfig);
         this.metaDefaults = sc.get(props, 'metaDefaults', {
             locale: 'en',
             viewport: 'width=device-width, initial-scale=1.0, maximum-scale=5.0, user-scalable=yes, viewport-fit=cover',
@@ -62,7 +76,22 @@ class Frontend
             renderEngine: this.renderEngine,
             getPartials: this.templateCache.getPartialsForDomain.bind(this.templateCache)
         });
+        this.dynamicFormRenderer = new DynamicFormRenderer({
+            renderEngine: this.renderEngine,
+            getPartials: this.templateCache.getPartialsForDomain.bind(this.templateCache),
+            projectRoot: this.projectRoot,
+            defaultDomain: this.defaultDomain,
+            events: this.events
+        });
         this.searchRequestHandler = new SearchRequestHandler(this);
+        this.dynamicFormRequestHandler = new DynamicFormRequestHandler({
+            dynamicForm: this.dynamicForm,
+            contentRenderer: this.contentRenderer,
+            requestProcessor: this.requestProcessor,
+            cacheManager: this.cacheManager,
+            enableJsonResponse: sc.get(props, 'enableJsonResponse', false),
+            events: this.events
+        });
     }
 
     async initialize()
@@ -96,7 +125,9 @@ class Frontend
             events: this.events,
             defaultDomain: this.defaultDomain,
             projectRoot: this.projectRoot,
-            publicPath: this.publicPath
+            publicPath: this.publicPath,
+            dynamicForm: this.dynamicForm,
+            dynamicFormRenderer: this.dynamicFormRenderer
         });
         this.contentRenderer.templateEngine = this.templateEngine;
         this.searchConfig.jsonFieldsParser = this.templateEngine.jsonFieldsParser;
@@ -107,6 +138,9 @@ class Frontend
         this.app.get(this.searchPath, async (req, res) => {
             return await this.searchRequestHandler.handleSearchRequest(req, res);
         });
+        this.app.post(this.dynamicFormPath, async (req, res) => {
+            return await this.dynamicFormRequestHandler.handleFormSubmission(req, res);
+        });
         this.app.get('*', async (req, res) => {
             return await this.handleRequest(req, res);
         });

package/lib/installer.js

@@ -168,7 +168,8 @@ class Installer
             '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-entity-access': 'default-entity-access.sql',
+            'install-dynamic-forms': 'default-forms.sql'
         };
         for(let checkboxName of Object.keys(executeFiles)){
             let fileName = executeFiles[checkboxName];

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

@@ -0,0 +1,187 @@
+/**
+ *
+ * Reldens - CMS - FormsTransformer
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class FormsTransformer
+{
+
+    constructor(props)
+    {
+        this.renderEngine = sc.get(props, 'renderEngine', false);
+        this.getPartials = sc.get(props, 'getPartials', false);
+        this.processAllTemplateFunctions = sc.get(props, 'processAllTemplateFunctions', false);
+        this.dynamicForm = sc.get(props, 'dynamicForm', false);
+        this.dynamicFormRenderer = sc.get(props, 'dynamicFormRenderer', false);
+        this.events = sc.get(props, 'events', false);
+        if(!this.events){
+            Logger.error('EventsManager not provided to FormsTransformer - forms functionality disabled');
+            this.isDisabled = true;
+        }
+    }
+
+    async transform(template, domain, req, systemVariables, enhancedData = {})
+    {
+        if(this.isDisabled){
+            return template;
+        }
+        let processedTemplate = template;
+        let formTags = this.findAllFormTags(template);
+        for(let i = formTags.length - 1; i >= 0; i--){
+            let tag = formTags[i];
+            let formKey = sc.get(tag.attributes, 'key', '');
+            if(!formKey){
+                Logger.warning('cmsForm tag missing key attribute');
+                processedTemplate = processedTemplate.substring(0, tag.start)+''+processedTemplate.substring(tag.end);
+                continue;
+            }
+            let formConfig = await this.dynamicForm.getFormConfig(formKey);
+            if(!formConfig){
+                Logger.warning('Form not found or disabled: '+formKey);
+                processedTemplate = processedTemplate.substring(0, tag.start)+''+processedTemplate.substring(tag.end);
+                continue;
+            }
+            let fieldsToRender = this.parseFieldsFilter(tag.attributes, formConfig);
+            if(!sc.isArray(fieldsToRender) || 0 === fieldsToRender.length){
+                processedTemplate = processedTemplate.substring(0, tag.start)+''+processedTemplate.substring(tag.end);
+                continue;
+            }
+            await this.events.emit('reldens.formsTransformer.beforeRender', {
+                formKey,
+                formConfig,
+                fieldsToRender,
+                formAttributes: tag.attributes,
+                domain,
+                req,
+                systemVariables,
+                enhancedData
+            });
+            let formContent = await this.dynamicFormRenderer.renderForm(
+                formConfig,
+                fieldsToRender,
+                domain,
+                req,
+                Object.assign({}, tag.attributes, {
+                    successRedirect: sc.get(tag.attributes, 'successRedirect', req.path),
+                    errorRedirect: sc.get(tag.attributes, 'errorRedirect', req.path)
+                }),
+                systemVariables,
+                enhancedData
+            );
+            await this.events.emit('reldens.formsTransformer.afterRender', {
+                formKey,
+                formConfig,
+                formContent,
+                domain,
+                req,
+                systemVariables,
+                enhancedData
+            });
+            processedTemplate = processedTemplate.substring(0, tag.start) +
+                formContent +
+                processedTemplate.substring(tag.end);
+        }
+        return processedTemplate;
+    }
+
+    findAllFormTags(template)
+    {
+        let formTags = [];
+        let pos = 0;
+        let cmsForm = '<cmsForm';
+        for(let tagStart = template.indexOf(cmsForm, pos); -1 !== tagStart; tagStart=template.indexOf(cmsForm, pos)){
+            let tagEnd = this.findFormTagEnd(template, tagStart);
+            if(-1 === tagEnd){
+                pos = tagStart + cmsForm.length;
+                continue;
+            }
+            let fullTag = template.substring(tagStart, tagEnd);
+            let attributes = this.parseFormAttributes(fullTag);
+            formTags.push({
+                start: tagStart,
+                end: tagEnd,
+                attributes: attributes,
+                fullTag: fullTag
+            });
+            pos = tagEnd;
+        }
+        return formTags;
+    }
+
+    findFormTagEnd(template, tagStart)
+    {
+        let inQuotes = false;
+        let quoteChar = '';
+        let selfCloseTag = '/>';
+        let openCloseTag = '</cmsForm>';
+        for(let i = tagStart; i < template.length; i++){
+            let char = template[i];
+            if(!inQuotes && ('"' === char || "'" === char)){
+                inQuotes = true;
+                quoteChar = char;
+                continue;
+            }
+            if(inQuotes && char === quoteChar && '\\' !== template[i - 1]){
+                inQuotes = false;
+                quoteChar = '';
+                continue;
+            }
+            if(!inQuotes){
+                if(template.substring(i, i + selfCloseTag.length) === selfCloseTag){
+                    return i + selfCloseTag.length;
+                }
+                if('>' === char){
+                    let closeIndex = template.indexOf(openCloseTag, i);
+                    if(-1 !== closeIndex){
+                        return closeIndex + openCloseTag.length;
+                    }
+                    return i + 1;
+                }
+            }
+        }
+        return -1;
+    }
+
+    parseFormAttributes(fullTag)
+    {
+        let attributes = {};
+        let valueRegex = /(\w+)=(['"])((?:(?!\2)[^\\]|\\.)*)(\2)/g;
+        for(let match of fullTag.matchAll(valueRegex)){
+            attributes[match[1]] = match[3];
+        }
+        let booleanRegex = /\b(\w+)(?!\s*=)/g;
+        for(let match of fullTag.matchAll(booleanRegex)){
+            if(!sc.hasOwn(attributes, match[1]) && 'cmsForm' !== match[1]){
+                attributes[match[1]] = true;
+            }
+        }
+        return attributes;
+    }
+
+    parseFieldsFilter(attributes, formConfig)
+    {
+        let fieldsFilter = sc.get(attributes, 'fields', '');
+        if(!fieldsFilter){
+            return formConfig.fields_schema;
+        }
+        let fieldsSchema = sc.isString(formConfig.fields_schema) ? sc.toJson(formConfig.fields_schema) : formConfig.fields_schema;
+        if(!sc.isArray(fieldsSchema)){
+            return [];
+        }
+        let requestedFields = fieldsFilter.split(',').map(f => f.trim()).filter(f => '' !== f);
+        let filteredFields = [];
+        for(let fieldName of requestedFields){
+            let field = sc.fetchByProperty(fieldsSchema, 'name', fieldName);
+            if(field){
+                filteredFields.push(field);
+            }
+        }
+        return filteredFields;
+    }
+
+}
+
+module.exports.FormsTransformer = FormsTransformer;

package/lib/template-engine.js

@@ -9,6 +9,7 @@ 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 { FormsTransformer } = require('./template-engine/forms-transformer');
 const { UrlTransformer } = require('./template-engine/url-transformer');
 const { AssetTransformer } = require('./template-engine/asset-transformer');
 const { DateTransformer } = require('./template-engine/date-transformer');
@@ -28,6 +29,8 @@ class TemplateEngine
         this.defaultDomain = sc.get(props, 'defaultDomain', 'default');
         this.projectRoot = sc.get(props, 'projectRoot', './');
         this.publicPath = sc.get(props, 'publicPath', './public');
+        this.dynamicForm = sc.get(props, 'dynamicForm', false);
+        this.dynamicFormRenderer = sc.get(props, 'dynamicFormRenderer', false);
         this.jsonFieldsParser = new JsonFieldsParser({entitiesConfig: sc.get(props, 'entitiesConfig', {})});
         this.systemVariablesProvider = new SystemVariablesProvider({
             defaultDomain: this.defaultDomain,
@@ -62,6 +65,17 @@ class TemplateEngine
             getPartials: this.getPartials,
             processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this)
         });
+        this.formsTransformer = false;
+        if(this.dynamicForm && this.dynamicFormRenderer){
+            this.formsTransformer = new FormsTransformer({
+                renderEngine: this.renderEngine,
+                getPartials: this.getPartials,
+                processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this),
+                dynamicForm: this.dynamicForm,
+                dynamicFormRenderer: this.dynamicFormRenderer,
+                events: this.events
+            });
+        }
         this.urlTransformer = new UrlTransformer();
         this.assetTransformer = new AssetTransformer();
         this.dateTransformer = new DateTransformer({
@@ -82,6 +96,9 @@ class TemplateEngine
             this.dateTransformer,
             this.translateTransformer
         ];
+        if(this.formsTransformer){
+            this.transformers.push(this.formsTransformer);
+        }
     }
 
     async processAllTemplateFunctions(template, domain, req, systemVariables, enhancedData = {})

package/lib/templates-list.js

@@ -22,6 +22,8 @@ module.exports.TemplatesList = {
     clearAllCacheButton: 'clear-all-cache-button.html',
     fields: {
         view: {
+            audio: 'audio.html',
+            audios: 'audios.html',
             text: 'text.html',
             textarea: 'textarea.html',
             image: 'image.html',

package/migrations/default-forms.sql

@@ -0,0 +1,22 @@
+
+-- Default CMS Forms
+
+CREATE TABLE `cms_forms` (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `form_key` VARCHAR(255) NOT NULL COLLATE 'utf8mb4_0900_ai_ci',
+    `fields_schema` JSON NOT NULL,
+    `enabled` TINYINT UNSIGNED NOT NULL DEFAULT '0',
+    `created_at` TIMESTAMP NOT NULL DEFAULT (NOW()),
+    `updated_at` TIMESTAMP NOT NULL DEFAULT (NOW()) ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY (`id`) USING BTREE,
+    UNIQUE INDEX `form_key` (`form_key`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+
+CREATE TABLE `cms_forms_submitted` (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `form_id` INT UNSIGNED NOT NULL,
+    `submitted_values` JSON NOT NULL,
+    PRIMARY KEY (`id`) USING BTREE,
+    INDEX `FK__cms_forms` (`form_id`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/cms",
     "scope": "@reldens",
-    "version": "0.21.0",
+    "version": "0.23.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -33,10 +33,10 @@
         "url": "https://github.com/damian-pastorini/reldens-cms/issues"
     },
     "dependencies": {
-        "@reldens/server-utils": "^0.23.0",
-        "@reldens/storage": "^0.62.0",
-        "@reldens/utils": "^0.50.0",
-        "dotenv": "^17.2.0",
+        "@reldens/server-utils": "^0.24.0",
+        "@reldens/storage": "^0.65.0",
+        "@reldens/utils": "^0.52.0",
+        "dotenv": "^17.2.1",
         "mustache": "^4.2.0"
     }
 }