@reldens/cms 0.15.0 → 0.16.0

package/lib/template-engine.js

@@ -13,6 +13,24 @@ 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 = '';
+    }
+
+    setCurrentDomain(domain)
+    {
+        this.currentDomain = domain;
+    }
+
+    async processAllTemplateFunctions(template)
+    {
+        return await this.processCustomPartials(
+            await this.processLoopCollections(
+                await this.processSingleFieldCollections(
+                    await this.processEntityFunctions(template)
+                )
+            )
+        );
     }
 
     async render(template, data, partials)
@@ -26,37 +44,43 @@ class TemplateEngine
             return '';
         }
         return this.renderEngine.render(
-            await this.processLoopCollections(
-                await this.processSingleFieldCollections(
-                    await this.processEntityFunctions(template)
-                )
-            ),
+            this.unescapeHtml(await this.processAllTemplateFunctions(template)),
             data,
             partials
         );
     }
 
+    unescapeHtml(text)
+    {
+        return text
+            .replace(/"/g, '"')
+            .replace(/'/g, "'")
+            .replace(/'/g, "'")
+            .replace(/=/g, '=')
+            .replace(///g, '/')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&amp;/g, '&');
+    }
+
     getEntityRegex()
     {
-        return /\{\{\s*entity\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]+)['"]\s*)?\)\s*\}\}/g;
+        return /<entity\s+name="([^"]+)"(?:\s+field="([^"]+)"\s+value="([^"]+)"|\s+id="([^"]+)")?\s*\/?>/g;
     }
 
     getSingleFieldCollectionRegex()
     {
-        return /\{\{\s*collection\(\s*['"]([^'"]+)['"]\s*,\s*(\{[^}]*\})\s*,\s*['"]([^'"]+)['"]\s*\)\s*\}\}/g;
+        return /<collection\s+name=(['"])([^'"]+)\1(?:\s+filters=(['"])([^'"]*)\3)?\s+field=(['"])([^'"]+)\5(?:\s+data=(['"])([^'"]*)\7)?\s*\/>/g;
     }
 
     getLoopCollectionStartRegex()
     {
-        return /\{\{\s*#collection\(\s*['"]([^'"]+)['"]\s*,\s*(\{[^}]*\})\s*\)\s*\}\}/g;
+        return /<collection\s+name=(['"])([^'"]+)\1(?:\s+filters=(['"])([^'"]*)\3)?(?:\s+data=(['"])([^'"]*)\5)?\s*>/g;
     }
 
-    getLoopCollectionEndRegex(tableName)
+    getLoopCollectionEndRegex()
     {
-        return new RegExp('\\{\\{\\s*\\/collection\\(\\s*[\'"]'
-            +this.escapeRegex(tableName)
-            +'[\'"]\\s*\\)\\s*\\}\\}'
-        );
+        return new RegExp('<\\/collection>');
     }
 
     async processEntityFunctions(template)
@@ -64,10 +88,18 @@ class TemplateEngine
         let processedTemplate = template;
         for(let match of template.matchAll(this.getEntityRegex())){
             let tableName = match[1];
-            let identifier = match[2];
-            let identifierField = match[3] || 'id';
-            let entityData = await this.fetchEntityForTemplate(tableName, identifier, identifierField);
-            processedTemplate = processedTemplate.replace(match[0], sc.get(entityData, 'content', ''));
+            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;
     }
@@ -76,13 +108,14 @@ class TemplateEngine
     {
         let processedTemplate = template;
         for(let match of template.matchAll(this.getSingleFieldCollectionRegex())){
-            let tableName = match[1];
-            let filtersJson = match[2];
-            let fieldName = match[3];
+            let tableName = match[2];
+            let filtersJson = sc.get(match, '4', '{}');
+            let fieldName = match[6];
+            let queryOptionsJson = sc.get(match, '8', '{}');
             processedTemplate = processedTemplate.replace(
                 match[0],
                 this.extractFieldValues(
-                    await this.fetchCollectionForTemplate(tableName, filtersJson),
+                    await this.fetchCollectionForTemplate(tableName, filtersJson, queryOptionsJson),
                     fieldName
                 )
             );
@@ -96,17 +129,172 @@ class TemplateEngine
         let matches = [...template.matchAll(this.getLoopCollectionStartRegex())];
         for(let i = matches.length - 1; i >= 0; i--){
             let startMatch = matches[i];
-            let tableName = startMatch[1];
-            let filtersJson = startMatch[2];
-            let loopResult = await this.processLoopCollection(processedTemplate, startMatch, tableName, filtersJson);
-            if(false !== loopResult){
+            let loopResult = await this.processLoopCollection(
+                processedTemplate,
+                startMatch,
+                startMatch[2],
+                sc.get(startMatch, '4', '{}'),
+                sc.get(startMatch, '6', '{}')
+            );
+            if(loopResult){
                 processedTemplate = loopResult;
             }
         }
         return processedTemplate;
     }
 
-    async processLoopCollection(template, startMatch, tableName, filtersJson)
+    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 searchPos = 0;
+        let partialTagName = '<partial';
+        for(let tagStart = template.indexOf(partialTagName, searchPos); -1 !== tagStart; tagStart = template.indexOf(partialTagName, searchPos)){
+            let tagEnd = this.findPartialTagEnd(template, tagStart);
+            if(-1 === tagEnd){
+                searchPos = tagStart + partialTagName.length;
+                continue;
+            }
+            let fullTag = template.substring(tagStart, tagEnd);
+            let nameMatch = fullTag.match(/name=["']([^"']+)["']/);
+            if(!nameMatch){
+                searchPos = tagStart + partialTagName.length;
+                continue;
+            }
+            let partialName = nameMatch[1];
+            let attributes = this.parsePartialAttributes(fullTag, partialName);
+            partialTags.push({
+                start: tagStart,
+                end: tagEnd,
+                name: partialName,
+                attributes: attributes,
+                fullTag: fullTag
+            });
+            searchPos = tagEnd;
+        }
+        return partialTags;
+    }
+
+    findPartialTagEnd(template, tagStart)
+    {
+        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, queryOptionsJson)
     {
         let startPos = startMatch.index;
         let startEnd = startPos + startMatch[0].length;
@@ -116,10 +304,9 @@ class TemplateEngine
             return false;
         }
         let endPos = startEnd + endMatch.index;
-        let renderedContent = await this.renderCollectionLoop(
-            template.substring(startEnd, endPos),
-            await this.fetchCollectionForTemplate(tableName, filtersJson)
-        );
+        let loopContent = template.substring(startEnd, endPos);
+        let collectionData = await this.fetchCollectionForTemplate(tableName, filtersJson, queryOptionsJson);
+        let renderedContent = await this.renderCollectionLoop(loopContent, collectionData);
         return template.substring(0, startPos) + renderedContent + template.substring(endPos + endMatch[0].length);
     }
 
@@ -127,11 +314,38 @@ class TemplateEngine
     {
         let renderedContent = '';
         for(let row of collectionData){
-            renderedContent += this.renderEngine.render(loopContent, {row}, {});
+            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')){
+                let renderedPartial = this.renderEngine.render(partialContent, {row: rowData}, this.getPartials(this.currentDomain));
+                processedContent = processedContent.substring(0, tag.start) + renderedPartial + 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 = '';
@@ -141,11 +355,6 @@ class TemplateEngine
         return fieldValues;
     }
 
-    escapeRegex(string)
-    {
-        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    }
-
     async fetchEntityForTemplate(tableName, identifier, identifierField)
     {
         let entity = this.dataServer.getEntity(tableName);
@@ -156,20 +365,79 @@ class TemplateEngine
         return await entity.loadOneBy(identifierField, identifier);
     }
 
-    async fetchCollectionForTemplate(tableName, filtersJson)
+    convertJsObjectToJson(jsObjectString)
+    {
+        if(!jsObjectString || '' === jsObjectString.trim()){
+            return '';
+        }
+        return jsObjectString.replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:/g, '$1"$2":');
+    }
+
+    async fetchCollectionForTemplate(tableName, filtersJson, queryOptionsJson)
     {
         let entity = this.dataServer.getEntity(tableName);
         if(!entity){
             Logger.warning('Entity not found in dataServer: '+tableName);
             return [];
         }
-        let filters = sc.toJson(filtersJson);
-        if(!filters){
-            return await entity.loadAll();
+        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 result = filters ? await entity.load(filters) : await entity.loadAll();
+        this.restoreEntityState(entity, originalState);
+        return result;
+    }
+
+    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 await entity.load(filters);
     }
 
 }
 
-module.exports.TemplateEngine = TemplateEngine;
+module.exports.TemplateEngine = TemplateEngine;

package/lib/templates-list.js

@@ -21,6 +21,7 @@ module.exports.TemplatesList = {
     fields: {
         view: {
             text: 'text.html',
+            textarea: 'textarea.html',
             image: 'image.html',
             images: 'images.html',
             link: 'link.html',
@@ -37,5 +38,13 @@ module.exports.TemplatesList = {
             button: 'button.html',
             file: 'file.html'
         }
+    },
+    sections: {
+        viewForm: {
+            'cms-pages': 'cms-pages.html',
+        },
+        editForm: {
+            'cms-pages': 'cms-pages.html',
+        }
     }
 };

package/migrations/default-blocks.sql

@@ -1,7 +1,7 @@
 
 -- Default CMS blocks:
 
-REPLACE INTO `cms_blocks` (`name`, `title`, `content`, `is_active`) VALUES
+REPLACE INTO `cms_blocks` (`name`, `title`, `content`, `enabled`) VALUES
     ('header-main', 'Main Header', '{{>header}}', 1),
     ('sidebar-left', 'Left Sidebar', '<aside class="sidebar-left">{{>sidebar}}</aside>', 1),
     ('sidebar-right', 'Right Sidebar', '<aside class="sidebar-right">{{>sidebar}}</aside>', 1),

package/migrations/default-entity-access.sql

@@ -1,9 +1,9 @@
 
 -- Default entity access rules:
 
-REPLACE INTO `cms_entity_access` (`entity_name`, `is_public`, `allowed_operations`) VALUES
+REPLACE INTO `entities_access` (`entity_name`, `is_public`, `allowed_operations`) VALUES
     ('cms_pages', TRUE, '["read"]'),
     ('routes', FALSE, '[]'),
     ('users', FALSE, '[]'),
     ('cms_blocks', FALSE, '[]'),
-    ('cms_entity_access', FALSE, '[]');
+    ('entities_access', FALSE, '[]');

package/migrations/default-homepage.sql

@@ -2,9 +2,29 @@
 -- Default homepage:
 
 -- Create a default homepage route if not exists
-REPLACE INTO `cms_pages` (`id`, `title`, `content`, `template`, `created_at`) VALUES
-(1, 'Home', '<h1>Welcome to Reldens CMS</h1><p>This is your homepage. Edit this content in the admin panel.</p>', NULL, NOW());
+REPLACE INTO `cms_pages` (
+    `id`, `title`, `content`, `template`, `meta_title`, `meta_description`,
+    `canonical_url`, `meta_robots`, `meta_og_title`, `meta_og_description`,
+    `meta_og_image`, `meta_twitter_card_type`, `status`, `locale`, `publish_date`, `expire_date`, `created_at`
+) VALUES (
+    1,
+    'Home',
+    '<h1>Welcome to Reldens CMS</h1><p>This is your homepage. Edit this content in the admin panel.</p>',
+    NULL,
+    'Home - Reldens CMS',
+    'Welcome to Reldens CMS',
+    NULL,
+    'index,follow',
+    'Home - Reldens CMS',
+    'Welcome to the Reldens CMS homepage',
+    NULL,
+    'summary',
+    'published',
+    'en',
+    NOW(),
+    NULL,
+    NOW()
+);
 
 -- Create a default route to the homepage
-REPLACE INTO `routes` (`id`, `path`, `router`, `content_id`, `title`, `meta_description`, `status`, `created_at`) VALUES
-(1, '/home', 'cmsPages', 1, 'Home', 'Welcome to Reldens CMS', 'published', NOW());
+REPLACE INTO `routes` (`id`, `path`, `router`, `cms_page_id`, `cache_ttl_seconds`, `enabled`, `created_at`) VALUES (1, '/home', 'cmsPages', 1, 3600, 1, NOW());

package/migrations/install.sql

@@ -5,34 +5,27 @@ CREATE TABLE IF NOT EXISTS `routes` (
     `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
     `path` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
     `router` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `content_id` INT UNSIGNED NOT NULL,
-    `title` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `meta_description` TEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `canonical_url` 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',
-    `og_title` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `og_description` TEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `og_image` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `twitter_card_type` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT 'summary',
-    `status` VARCHAR(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT 'published',
-    `publish_at` TIMESTAMP NULL,
-    `locale` VARCHAR(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT 'en',
+    `cms_page_id` INT UNSIGNED NOT NULL,
     `cache_ttl_seconds` INT UNSIGNED NULL DEFAULT 3600,
+    `enabled` TINYINT UNSIGNED NOT NULL DEFAULT '1',
+    `domain` VARCHAR(255) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
     `created_at` TIMESTAMP NOT NULL DEFAULT (NOW()),
     `updated_at` TIMESTAMP NOT NULL DEFAULT (NOW()) ON UPDATE CURRENT_TIMESTAMP,
     PRIMARY KEY (`id`) USING BTREE,
-    UNIQUE KEY `path` (`path`) USING BTREE
+    UNIQUE KEY `path_domain` (`path`, `domain`) USING BTREE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
 
-CREATE TABLE IF NOT EXISTS `cms_pages_meta` (
+CREATE TABLE IF NOT EXISTS `cms_categories` (
     `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
-    `page_id` INT UNSIGNED NOT NULL,
-    `publish_date` TIMESTAMP NULL,
-    `expire_date` TIMESTAMP NULL,
+    `name` VARCHAR(255) NOT NULL COLLATE 'utf8mb4_unicode_ci',
+    `title` VARCHAR(255) NOT NULL COLLATE 'utf8mb4_unicode_ci',
+    `enabled` TINYINT UNSIGNED NOT NULL DEFAULT '1',
+    `parent_id` INT UNSIGNED 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,
-    KEY `page_id` (`page_id`) USING BTREE
+    INDEX `FK_cms_categories_cms_categories` (`parent_id`) USING BTREE,
+    CONSTRAINT `FK_cms_categories_cms_categories` FOREIGN KEY (`parent_id`) REFERENCES `cms_categories` (`id`) ON UPDATE CASCADE ON DELETE NO ACTION
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
 
 CREATE TABLE IF NOT EXISTS `cms_pages` (
@@ -43,21 +36,26 @@ CREATE TABLE IF NOT EXISTS `cms_pages` (
     `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',
-    `created_at` TIMESTAMP NOT NULL DEFAULT (NOW()),
-    `updated_at` TIMESTAMP NOT NULL DEFAULT (NOW()) ON UPDATE CURRENT_TIMESTAMP,
-    PRIMARY KEY (`id`) USING BTREE
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-
-CREATE TABLE IF NOT EXISTS `entities_meta` (
-    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
-    `entity_name` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `entity_id` INT UNSIGNED NOT NULL,
-    `meta_key` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `meta_value` LONGTEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
+    `category_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_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,
     `created_at` TIMESTAMP NOT NULL DEFAULT (NOW()),
     `updated_at` TIMESTAMP NOT NULL DEFAULT (NOW()) ON UPDATE CURRENT_TIMESTAMP,
     PRIMARY KEY (`id`) USING BTREE,
-    UNIQUE KEY `entity_meta` (`entity_name`, `entity_id`, `meta_key`) USING BTREE
+    INDEX `FK_cms_pages_cms_categories` (`category_id`) USING BTREE,
+    CONSTRAINT `FK_cms_pages_cms_categories` FOREIGN KEY (`category_id`) REFERENCES `cms_categories` (`id`) ON UPDATE CASCADE ON DELETE NO ACTION
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
 
 CREATE TABLE IF NOT EXISTS `cms_blocks` (
@@ -65,19 +63,17 @@ CREATE TABLE IF NOT EXISTS `cms_blocks` (
     `name` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
     `title` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
     `content` LONGTEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `template_file` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
-    `variables` JSON NULL,
-    `is_active` BOOLEAN NOT NULL DEFAULT TRUE,
+    `enabled` TINYINT UNSIGNED NOT NULL DEFAULT '1',
     `created_at` TIMESTAMP NOT NULL DEFAULT (NOW()),
     `updated_at` TIMESTAMP NOT NULL DEFAULT (NOW()) ON UPDATE CURRENT_TIMESTAMP,
     PRIMARY KEY (`id`) USING BTREE,
     UNIQUE KEY `name` (`name`) USING BTREE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
 
-CREATE TABLE IF NOT EXISTS `cms_entity_access` (
+CREATE TABLE IF NOT EXISTS `entities_access` (
     `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
     `entity_name` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
-    `is_public` BOOLEAN NOT NULL DEFAULT FALSE,
+    `is_public` TINYINT UNSIGNED NOT NULL DEFAULT '0',
     `allowed_operations` JSON NULL DEFAULT ('["read"]'),
     `access_rules` JSON NULL,
     `created_at` TIMESTAMP NOT NULL DEFAULT (NOW()),

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/cms",
     "scope": "@reldens",
-    "version": "0.15.0",
+    "version": "0.16.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -33,8 +33,8 @@
         "url": "https://github.com/damian-pastorini/reldens-cms/issues"
     },
     "dependencies": {
-        "@reldens/server-utils": "^0.18.0",
-        "@reldens/storage": "^0.51.0",
+        "@reldens/server-utils": "^0.19.0",
+        "@reldens/storage": "^0.56.0",
         "@reldens/utils": "^0.50.0",
         "dotenv": "^16.5.0",
         "mustache": "^4.2.0"