@reldens/cms 0.18.0 → 0.20.0

package/lib/template-engine.js

@@ -4,8 +4,17 @@
  *
  */
 
-const { Logger, sc } = require('@reldens/utils');
 const { JsonFieldsParser } = require('./json-fields-parser');
+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
 {
@@ -15,45 +24,144 @@ class TemplateEngine
         this.renderEngine = sc.get(props, 'renderEngine', false);
         this.dataServer = sc.get(props, 'dataServer', false);
         this.getPartials = sc.get(props, 'getPartials', false);
-        this.currentDomain = '';
-        this.jsonFieldsParser = new JsonFieldsParser({
-            entitiesConfig: sc.get(props, 'entitiesConfig', {})
+        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,
+            processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this)
+        });
+        this.collectionsSingleTransformer = new CollectionsSingleTransformer({
+            dataServer: this.dataServer,
+            jsonFieldsParser: this.jsonFieldsParser,
+            renderEngine: this.renderEngine,
+            getPartials: this.getPartials,
+            findAllPartialTags: this.findAllPartialTags.bind(this),
+            loadPartialTemplate: this.loadPartialTemplate.bind(this),
+            processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this)
+        });
+        this.collectionsTransformer = new CollectionsTransformer({
+            dataServer: this.dataServer,
+            jsonFieldsParser: this.jsonFieldsParser,
+            renderEngine: this.renderEngine,
+            getPartials: this.getPartials,
+            findAllPartialTags: this.findAllPartialTags.bind(this),
+            loadPartialTemplate: this.loadPartialTemplate.bind(this),
+            processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this)
+        });
+        this.partialsTransformer = new PartialsTransformer({
+            renderEngine: this.renderEngine,
+            getPartials: this.getPartials
+        });
+        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.urlTransformer,
+            this.assetTransformer,
+            this.dateTransformer,
+            this.translateTransformer
+        ];
     }
 
-    setCurrentDomain(domain)
-    {
-        this.currentDomain = domain;
-    }
-
-    async processAllTemplateFunctions(template)
+    async processAllTemplateFunctions(template, domain, req, systemVariables)
     {
-        return await this.processCustomPartials(
-            await this.processLoopCollections(
-                await this.processSingleFieldCollections(
-                    await this.processEntityFunctions(template)
-                )
-            )
-        );
+        let processedTemplate = template;
+        for(let transformer of this.transformers){
+            if(sc.isFunction(transformer.transform)){
+                processedTemplate = await transformer.transform(processedTemplate, domain, req, systemVariables);
+            }
+        }
+        return processedTemplate;
     }
 
-    async render(template, data, partials)
+    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)),
+        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
+        );
+        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
@@ -67,427 +175,14 @@ class TemplateEngine
             .replace(/&/g, '&');
     }
 
-    getEntityRegex()
-    {
-        return /<entity\s+name="([^"]+)"(?:\s+field="([^"]+)"\s+value="([^"]+)"|\s+id="([^"]+)")?\s*\/?>/g;
-    }
-
-    getSingleFieldCollectionRegex()
-    {
-        return /<collection\s+([^>]+)\/>/g;
-    }
-
-    getLoopCollectionStartRegex()
-    {
-        return /<collection\s+([^>]+)>/g;
-    }
-
-    getLoopCollectionEndRegex()
-    {
-        return new RegExp('<\\/collection>');
-    }
-
-    extractAttributeValue(tagContent, attributeName)
-    {
-        let regex = new RegExp(attributeName + '=([\'"])([^\'"]*)\\1');
-        let match = tagContent.match(regex);
-        return match ? match[2] : '';
-    }
-
-    async processEntityFunctions(template)
-    {
-        let processedTemplate = template;
-        for(let match of template.matchAll(this.getEntityRegex())){
-            let tableName = match[1];
-            let field = sc.get(match, '2', 'id');
-            let value = sc.get(match, '3', sc.get(match, '4', ''));
-            if(!value){
-                Logger.warning('Entity tag missing value: '+match[0]);
-                continue;
-            }
-            processedTemplate = processedTemplate.replace(
-                match[0],
-                await this.processAllTemplateFunctions(
-                    sc.get(await this.fetchEntityForTemplate(tableName, value, field), 'content', '')
-                )
-            );
-        }
-        return processedTemplate;
-    }
-
-    async processSingleFieldCollections(template)
-    {
-        let processedTemplate = template;
-        for(let match of template.matchAll(this.getSingleFieldCollectionRegex())){
-            let tagContent = match[1];
-            if(!tagContent.includes('field=')){
-                continue;
-            }
-            let tableName = this.extractAttributeValue(tagContent, 'name');
-            let filtersJson = this.extractAttributeValue(tagContent, 'filters');
-            let queryOptionsJson = this.extractAttributeValue(tagContent, 'data');
-            let relationsString = this.extractAttributeValue(tagContent, 'relations');
-            let fieldName = this.extractAttributeValue(tagContent, 'field');
-            processedTemplate = processedTemplate.replace(
-                match[0],
-                this.extractFieldValues(
-                    await this.fetchCollectionForTemplate(tableName, filtersJson, queryOptionsJson, relationsString),
-                    fieldName
-                )
-            );
-        }
-        return processedTemplate;
-    }
-
-    async processLoopCollections(template)
-    {
-        let processedTemplate = template;
-        let matches = [...template.matchAll(this.getLoopCollectionStartRegex())];
-        for(let i = matches.length - 1; i >= 0; i--){
-            let startMatch = matches[i];
-            let tagContent = startMatch[1];
-            if(tagContent.includes('field=')){
-                continue;
-            }
-            let tableName = this.extractAttributeValue(tagContent, 'name');
-            let filtersJson = this.extractAttributeValue(tagContent, 'filters');
-            let queryOptionsJson = this.extractAttributeValue(tagContent, 'data');
-            let relationsString = this.extractAttributeValue(tagContent, 'relations');
-            let loopResult = await this.processLoopCollection(
-                processedTemplate,
-                startMatch,
-                tableName,
-                filtersJson,
-                relationsString,
-                queryOptionsJson
-            );
-            if(loopResult){
-                processedTemplate = loopResult;
-            }
-        }
-        return processedTemplate;
-    }
-
-    async processCustomPartials(template)
-    {
-        let processedTemplate = template;
-        let partialTags = this.findAllPartialTags(template);
-        for(let i = partialTags.length - 1; i >= 0; i--){
-            let tag = partialTags[i];
-            let partialContent = this.loadPartialTemplate(tag.name);
-            if(!partialContent){
-                Logger.warning('Partial template not found: ' + tag.name);
-                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};
-            processedTemplate = processedTemplate.substring(0, tag.start) +
-                this.renderEngine.render(wrapperTemplate, renderData, partials) +
-                processedTemplate.substring(tag.end);
-        }
-        return processedTemplate;
-    }
-
     findAllPartialTags(template)
     {
-        let partialTags = [];
-        let pos = 0;
-        let partial = '<partial';
-        for(let tagStart = template.indexOf(partial, pos); -1 !== tagStart; tagStart=template.indexOf(partial, pos)){
-            let tagEnd = this.findPartialTagEnd(template, tagStart);
-            if(-1 === tagEnd){
-                pos = tagStart + partial.length;
-                continue;
-            }
-            let fullTag = template.substring(tagStart, tagEnd);
-            let nameMatch = fullTag.match(/name=["']([^"']+)["']/);
-            if(!nameMatch){
-                pos = tagStart + partial.length;
-                continue;
-            }
-            let partialName = nameMatch[1];
-            let attributes = this.parsePartialAttributes(fullTag, partialName);
-            partialTags.push({
-                start: tagStart,
-                end: tagEnd,
-                name: partialName,
-                attributes: attributes,
-                fullTag: fullTag
-            });
-            pos = tagEnd;
-        }
-        return partialTags;
+        return this.partialsTransformer.findAllPartialTags(template);
     }
 
-    findPartialTagEnd(template, tagStart)
+    loadPartialTemplate(partialName, domain)
     {
-        let inQuotes = false;
-        let quoteChar = '';
-        let selfCloseTag = '/>';
-        let openCloseTag = '</partial>';
-        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;
-    }
-
-    parsePartialAttributes(fullTag, partialName)
-    {
-        let namePattern = 'name=' + this.getQuotePattern(fullTag, partialName);
-        let nameIndex = fullTag.indexOf(namePattern);
-        if(-1 === nameIndex){
-            return {};
-        }
-        let attributesStart = nameIndex + namePattern.length;
-        let attributesEnd = fullTag.lastIndexOf('/>');
-        if(-1 === attributesEnd){
-            attributesEnd = fullTag.lastIndexOf('</partial>');
-        }
-        if(-1 === attributesEnd){
-            attributesEnd = fullTag.lastIndexOf('>');
-        }
-        if(-1 === attributesEnd || attributesEnd <= attributesStart){
-            return {};
-        }
-        let attributesString = fullTag.substring(attributesStart, attributesEnd).trim();
-        return this.extractAttributesObject(attributesString);
-    }
-
-    getQuotePattern(fullTag, partialName)
-    {
-        if(fullTag.includes('name="' + partialName + '"')){
-            return '"' + partialName + '"';
-        }
-        if(fullTag.includes("name='" + partialName + "'")){
-            return "'" + partialName + "'";
-        }
-        return '"' + partialName + '"';
-    }
-
-    extractAttributesObject(attributesString)
-    {
-        if(!attributesString){
-            return {};
-        }
-        let attributes = {};
-        let valueRegex = /(\w+)=(['"])((?:(?!\2)[^\\]|\\.)*)(\2)/g;
-        for(let match of attributesString.matchAll(valueRegex)){
-            attributes[match[1]] = match[3];
-        }
-        let booleanRegex = /\b(\w+)(?!\s*=)/g;
-        for(let match of attributesString.matchAll(booleanRegex)){
-            if(!sc.hasOwn(attributes, match[1])){
-                attributes[match[1]] = true;
-            }
-        }
-        return attributes;
-    }
-
-    loadPartialTemplate(partialName)
-    {
-        if(!this.getPartials){
-            return false;
-        }
-        let partials = this.getPartials(this.currentDomain);
-        if(sc.hasOwn(partials, partialName)){
-            return partials[partialName];
-        }
-        return false;
-    }
-
-    async processLoopCollection(template, startMatch, tableName, filtersJson, relationsString, queryOptionsJson)
-    {
-        let startPos = startMatch.index;
-        let startEnd = startPos + startMatch[0].length;
-        let endMatch = this.getLoopCollectionEndRegex(tableName).exec(template.substring(startEnd));
-        if(!endMatch){
-            Logger.warning('No matching end tag found for collection: '+tableName);
-            return false;
-        }
-        let endPos = startEnd + endMatch.index;
-        let loopContent = template.substring(startEnd, endPos);
-        let collectionData = await this.fetchCollectionForTemplate(
-            tableName,
-            filtersJson,
-            queryOptionsJson,
-            relationsString
-        );
-        let renderedContent = await this.renderCollectionLoop(loopContent, collectionData);
-        return template.substring(0, startPos) + renderedContent + template.substring(endPos + endMatch[0].length);
-    }
-
-    async renderCollectionLoop(loopContent, collectionData)
-    {
-        let renderedContent = '';
-        for(let row of collectionData){
-            renderedContent += await this.processPartialsInLoop(loopContent, row);
-        }
-        return renderedContent;
-    }
-
-    async processPartialsInLoop(content, rowData)
-    {
-        let processedContent = content;
-        let partialTags = this.findAllPartialTags(content);
-        for(let i = partialTags.length - 1; i >= 0; i--){
-            let tag = partialTags[i];
-            let partialContent = this.loadPartialTemplate(tag.name);
-            if(!partialContent){
-                Logger.warning('Partial template not found: ' + tag.name);
-                processedContent = processedContent.substring(0, tag.start)+''+processedContent.substring(tag.end);
-                continue;
-            }
-            if(sc.hasOwn(tag.attributes, 'row')){
-                processedContent = processedContent.substring(0, tag.start)
-                    +this.renderEngine.render(partialContent, {row: rowData}, this.getPartials(this.currentDomain))
-                    +processedContent.substring(tag.end);
-                continue;
-            }
-            let wrapperTemplate = '{{#vars}}{{> ' + tag.name + '}}{{/vars}}';
-            let renderData = { vars: tag.attributes };
-            let partials = {[tag.name]: partialContent};
-            processedContent = processedContent.substring(0, tag.start) +
-                this.renderEngine.render(wrapperTemplate, renderData, partials) +
-                processedContent.substring(tag.end);
-        }
-        return this.renderEngine.render(processedContent, {row: rowData}, this.getPartials(this.currentDomain));
-    }
-
-    extractFieldValues(collectionData, fieldName)
-    {
-        let fieldValues = '';
-        for(let row of collectionData){
-            fieldValues += sc.get(row, fieldName, '');
-        }
-        return fieldValues;
-    }
-
-    async fetchEntityForTemplate(tableName, identifier, identifierField)
-    {
-        let entity = this.dataServer.getEntity(tableName);
-        if(!entity){
-            Logger.warning('Entity not found in dataServer: '+tableName);
-            return false;
-        }
-        let result = await entity.loadOneBy(identifierField, identifier);
-        if(!result){
-            return false;
-        }
-        return this.jsonFieldsParser.parseJsonFields(
-            result,
-            this.jsonFieldsParser.getJsonFieldsForEntity(tableName)
-        );
-    }
-
-    convertJsObjectToJson(jsObjectString)
-    {
-        if(!jsObjectString || '' === jsObjectString.trim()){
-            return '';
-        }
-        return jsObjectString.replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:/g, '$1"$2":');
-    }
-
-    parseRelationsString(relationsString)
-    {
-        if(!relationsString || '' === relationsString.trim()){
-            return [];
-        }
-        return relationsString.split(',').map(relation => relation.trim()).filter(relation => '' !== relation);
-    }
-
-    async fetchCollectionForTemplate(tableName, filtersJson, queryOptionsJson, relationsString)
-    {
-        let entity = this.dataServer.getEntity(tableName);
-        if(!entity){
-            Logger.warning('Entity not found in dataServer: '+tableName);
-            return [];
-        }
-        let filters = false;
-        if(filtersJson && '' !== filtersJson.trim()){
-            let convertedFiltersJson = this.convertJsObjectToJson(filtersJson);
-            filters = sc.parseJson(convertedFiltersJson, false);
-            if(!filters){
-                Logger.warning('Invalid filters JSON: '+filtersJson);
-            }
-        }
-        let originalState = this.preserveEntityState(entity);
-        let queryOptions = {};
-        if(queryOptionsJson && '' !== queryOptionsJson.trim()){
-            let convertedOptionsJson = this.convertJsObjectToJson(queryOptionsJson);
-            queryOptions = sc.parseJson(convertedOptionsJson, {});
-            if(!queryOptions){
-                Logger.warning('Invalid query options JSON: '+queryOptionsJson);
-                queryOptions = {};
-            }
-        }
-        this.applyQueryOptions(entity, queryOptions);
-        let relations = this.parseRelationsString(relationsString);
-        let result = 0 < relations.length
-            ? await entity.loadWithRelations(filters || {}, relations)
-            : filters ? await entity.load(filters) : await entity.loadAll();
-        this.restoreEntityState(entity, originalState);
-        return this.jsonFieldsParser.parseJsonFields(
-            result,
-            this.jsonFieldsParser.getJsonFieldsForEntity(tableName)
-        );
-    }
-
-    preserveEntityState(entity)
-    {
-        return {
-            limit: entity.limit,
-            offset: entity.offset,
-            sortBy: entity.sortBy,
-            sortDirection: entity.sortDirection
-        };
-    }
-
-    restoreEntityState(entity, originalState)
-    {
-        entity.limit = originalState.limit;
-        entity.offset = originalState.offset;
-        entity.sortBy = originalState.sortBy;
-        entity.sortDirection = originalState.sortDirection;
-    }
-
-    applyQueryOptions(entity, queryOptions)
-    {
-        if(sc.hasOwn(queryOptions, 'limit')){
-            entity.limit = queryOptions.limit;
-        }
-        if(sc.hasOwn(queryOptions, 'offset')){
-            entity.offset = queryOptions.offset;
-        }
-        if(sc.hasOwn(queryOptions, 'sortBy')){
-            entity.sortBy = queryOptions.sortBy;
-        }
-        if(sc.hasOwn(queryOptions, 'sortDirection')){
-            entity.sortDirection = queryOptions.sortDirection;
-        }
+        return this.partialsTransformer.loadPartialTemplate(partialName, domain);
     }
 
 }

package/lib/templates-list.js

@@ -19,6 +19,7 @@ module.exports.TemplatesList = {
     paginationLink: 'pagination-link.html',
     defaultCopyRight: 'default-copyright.html',
     cacheCleanButton: 'cache-clean-button.html',
+    clearAllCacheButton: 'clear-all-cache-button.html',
     fields: {
         view: {
             text: 'text.html',

package/migrations/install.sql

@@ -29,34 +29,34 @@ CREATE TABLE IF NOT EXISTS `cms_categories` (
 
 CREATE TABLE IF NOT EXISTS `cms_pages` (
     `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
-    `title` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `content` LONGTEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `json_data` JSON NULL,
-    `template` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `layout` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT 'default',
+    `title` VARCHAR(255) NOT NULL COLLATE 'utf8mb4_unicode_ci',
+    `content` LONGTEXT NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
+    `json_data` JSON NULL DEFAULT NULL,
+    `template` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
+    `layout` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
     `category_id` INT UNSIGNED NULL DEFAULT NULL,
     `route_id` INT UNSIGNED NULL DEFAULT NULL,
     `enabled` TINYINT UNSIGNED NOT NULL DEFAULT '1',
-    `meta_title` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `meta_description` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `meta_robots` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT 'index,follow',
+    `meta_title` VARCHAR(255) NOT NULL COLLATE 'utf8mb4_unicode_ci',
+    `meta_description` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
+    `meta_robots` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
     `meta_theme_color` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
-    `meta_og_title` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `meta_og_description` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `meta_og_image` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `meta_twitter_card_type` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT 'summary',
-    `canonical_url` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `status` VARCHAR(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT 'published',
-    `locale` VARCHAR(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT 'en',
-    `publish_date` TIMESTAMP NULL,
-    `expire_date` TIMESTAMP NULL,
+    `meta_og_title` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
+    `meta_og_description` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
+    `meta_og_image` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
+    `meta_twitter_card_type` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
+    `canonical_url` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
+    `status` VARCHAR(20) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
+    `locale` VARCHAR(10) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
+    `publish_date` TIMESTAMP NULL DEFAULT (NOW()),
+    `expire_date` TIMESTAMP NULL DEFAULT NULL,
     `created_at` TIMESTAMP NOT NULL DEFAULT (NOW()),
     `updated_at` TIMESTAMP NOT NULL DEFAULT (NOW()) ON UPDATE CURRENT_TIMESTAMP,
     PRIMARY KEY (`id`) USING BTREE,
     INDEX `FK_cms_pages_cms_categories` (`category_id`) USING BTREE,
     INDEX `FK_cms_pages_routes` (`route_id`) USING BTREE,
     CONSTRAINT `FK_cms_pages_cms_categories` FOREIGN KEY (`category_id`) REFERENCES `cms_categories` (`id`) ON UPDATE CASCADE ON DELETE NO ACTION,
-    CONSTRAINT `FK_cms_pages_routes` FOREIGN KEY (`route_id`) REFERENCES `routes` (`id`) ON UPDATE CASCADE ON DELETE SET NULL
+    CONSTRAINT `FK_cms_pages_routes` FOREIGN KEY (`route_id`) REFERENCES `routes` (`id`) ON UPDATE CASCADE ON DELETE NO ACTION
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
 
 CREATE TABLE IF NOT EXISTS `cms_blocks` (