@reldens/cms 0.1.0

package/lib/manager.js

@@ -0,0 +1,171 @@
+/**
+ *
+ * Reldens - CMS - Manager
+ *
+ */
+
+const { AppServerFactory, FileHandler, Encryptor } = require('@reldens/server-utils');
+const { DriversMap } = require('@reldens/storage');
+const { AdminManager } = require('./admin-manager');
+const { Installer } = require('./installer');
+const { Storefront } = require('./storefront');
+const { Logger, sc } = require('@reldens/utils');
+const dotenv = require('dotenv');
+const mustache = require('mustache');
+
+class Manager
+{
+    constructor(props = {})
+    {
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.envFilePath = FileHandler.joinPaths(this.projectRoot, '.env');
+        this.installLockPath = FileHandler.joinPaths(this.projectRoot, 'install.lock');
+        dotenv.config({path: this.envFilePath});
+        this.config = this.loadConfigFromEnv();
+        this.entities = sc.get(props, 'entities', {});
+        this.authenticationMethod = sc.get(props, 'authenticationMethod', 'db-users');
+        this.authenticationCallback = sc.get(props, 'authenticationCallback', false);
+        this.appServerFactory = new AppServerFactory();
+        this.installer = new Installer({
+            projectRoot: this.projectRoot
+        });
+        this.dataServer = false;
+        this.app = false;
+        this.appServer = false;
+        this.adminManager = false;
+        this.storefront = false;
+    }
+
+    loadConfigFromEnv()
+    {
+        return {
+            host: process.env.RELDENS_CMS_HOST || 'http://localhost',
+            port: Number(process.env.RELDENS_CMS_PORT || 3000),
+            adminPath: process.env.RELDENS_CMS_ADMIN_PATH || '/reldens-admin',
+            adminSecret: process.env.RELDENS_CMS_ADMIN_SECRET || '',
+            database: {
+                client: process.env.RELDENS_CMS_DB_CLIENT || 'mysql2',
+                host: process.env.RELDENS_CMS_DB_HOST || 'localhost',
+                port: Number(process.env.RELDENS_CMS_DB_PORT || 3306),
+                name: process.env.RELDENS_CMS_DB_NAME || 'reldens_cms',
+                user: process.env.RELDENS_CMS_DB_USER || '',
+                password: process.env.RELDENS_CMS_DB_PASSWORD || '',
+                driver: process.env.RELDENS_CMS_DB_DRIVER || 'prisma'
+            }
+        };
+    }
+
+    isInstalled()
+    {
+        return FileHandler.exists(this.installLockPath);
+    }
+
+    async start()
+    {
+        let createdAppServer = this.appServerFactory.createAppServer();
+        if(this.appServerFactory.error.message){
+            Logger.error('App server error: '+this.appServerFactory.error.message);
+            return false;
+        }
+        this.app = createdAppServer.app;
+        this.appServer = createdAppServer.appServer;
+        if(!this.isInstalled()){
+            Logger.info('CMS not installed, preparing setup');
+            await this.installer.prepareSetup(this.app, this.appServerFactory);
+            await this.appServer.listen(this.config.port);
+            Logger.info('Installer running on '+this.config.host+':'+this.config.port);
+            return true;
+        }
+        try {
+            await this.initializeDataServer();
+            await this.initializeAdminManager();
+            await this.initializeStorefront();
+            await this.appServer.listen(this.config.port);
+            Logger.info('CMS running on '+this.config.host+':'+this.config.port);
+            return true;
+        } catch (error) {
+            Logger.error('Failed to start CMS: '+error.message);
+            return false;
+        }
+    }
+
+    async initializeDataServer()
+    {
+        let dbConfig = {
+            client: this.config.database.client,
+            config: {
+                host: this.config.database.host,
+                port: this.config.database.port,
+                database: this.config.database.name,
+                user: this.config.database.user,
+                password: this.config.database.password
+            }
+        };
+        let DriverClass = DriversMap[this.config.database.driver];
+        if(!DriverClass){
+            throw new Error('Invalid database driver: '+this.config.database.driver);
+        }
+        this.dataServer = new DriverClass(dbConfig);
+        if(!await this.dataServer.connect()){
+            throw new Error('Failed to connect to database');
+        }
+        await this.dataServer.generateEntities();
+        return true;
+    }
+
+    async initializeAdminManager()
+    {
+        let authenticationCallback = this.authenticationCallback;
+        if('db-users' === this.authenticationMethod){
+            authenticationCallback = async (email, password, roleId) => {
+                let usersEntity = this.dataServer.getEntity('users');
+                if(!usersEntity){
+                    return false;
+                }
+                let user = await usersEntity.loadOneBy('email', email);
+                if(!user){
+                    return false;
+                }
+                if(Number(user.role_id) !== Number(roleId)){
+                    return false;
+                }
+                return Encryptor.validatePassword(password, user.password) ? user : false;
+            };
+        }
+        let adminConfig = {
+            events: false,
+            renderCallback: this.renderCallback.bind(this),
+            dataServer: this.dataServer,
+            authenticationCallback,
+            app: this.app,
+            appServerFactory: this.appServerFactory,
+            secret: this.config.adminSecret,
+            rootPath: this.config.adminPath,
+            adminRoleId: 99,
+            entities: this.entities
+        };
+        this.adminManager = new AdminManager(adminConfig);
+        await this.adminManager.setupAdmin();
+        return true;
+    }
+
+    async renderCallback(template, params)
+    {
+        if(!template){
+            return '';
+        }
+        return mustache.render(template, params);
+    }
+
+    async initializeStorefront()
+    {
+        this.storefront = new Storefront({
+            app: this.app,
+            dataServer: this.dataServer,
+            projectRoot: this.projectRoot
+        });
+        return await this.storefront.initialize();
+    }
+}
+
+module.exports.Manager = Manager;

package/lib/storefront.js

@@ -0,0 +1,228 @@
+/**
+ *
+ * Reldens - CMS - Storefront
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+const mustache = require('mustache');
+
+class Storefront
+{
+
+    constructor(props)
+    {
+        this.app = sc.get(props, 'app', false);
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.templatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
+        this.publicPath = FileHandler.joinPaths(this.projectRoot, 'public');
+        this.encoding = sc.get(props, 'encoding', 'utf8');
+        this.error = false;
+    }
+
+    async initialize()
+    {
+        if(!this.app || !this.dataServer){
+            this.error = 'Missing app or dataServer';
+            return false;
+        }
+        if(!FileHandler.exists(this.templatesPath)){
+            Logger.error('Templates folder not found: '+this.templatesPath);
+            return false;
+        }
+        if(!FileHandler.exists(this.publicPath)){
+            Logger.error('Public folder not found: '+this.publicPath);
+            return false;
+        }
+        this.setupStaticAssets();
+        this.app.get('*', async (req, res) => {
+            return await this.handleRequest(req, res);
+        });
+        return true;
+    }
+
+    setupStaticAssets()
+    {
+        if(!this.app || !this.publicPath){
+            return false;
+        }
+        this.app.use(this.app._router.constructor.static(this.publicPath));
+        return true;
+    }
+
+    async handleRequest(req, res)
+    {
+        let path = req.path;
+        if('/favicon.ico' === path){
+            return res.status(404).send('');
+        }
+        try {
+            let route = await this.findRouteByPath(path);
+            if(route){
+                return await this.renderContentFromRoute(res, route);
+            }
+            let pathSegments = path.split('/').filter(segment => segment !== '');
+            if(0 < pathSegments.length){
+                let entityResult = await this.findEntityByPath(pathSegments);
+                if(entityResult){
+                    return await this.renderContentFromEntity(
+                        res,
+                        entityResult.entity,
+                        entityResult.entityName
+                    );
+                }
+            }
+            let templatePath = this.findTemplateByPath(path);
+            if(templatePath){
+                return await this.renderTemplateOnly(res, templatePath);
+            }
+            return await this.renderNotFoundPage(res);
+        } catch (error) {
+            Logger.error('Request handling error: '+error.message);
+            return res.status(500).send('Internal server error');
+        }
+    }
+
+    async findRouteByPath(path)
+    {
+        if('/' === path){
+            path = '/home';
+        }
+        let routesEntity = this.dataServer.getEntity('routes');
+        if(!routesEntity){
+            return false;
+        }
+        return await routesEntity.loadOneBy('path', path);
+    }
+
+    async findEntityByPath(pathSegments)
+    {
+        if(1 > pathSegments.length){
+            return false;
+        }
+        let entityName = pathSegments[0];
+        let entityId = 2 > pathSegments.length ? false : pathSegments[1];
+        if(!entityId){
+            return false;
+        }
+        let entity = this.dataServer.getEntity(entityName);
+        if(!entity){
+            return false;
+        }
+        let loadedEntity = await entity.loadById(entityId);
+        if(!loadedEntity){
+            return false;
+        }
+        return {
+            entity: loadedEntity,
+            entityName
+        };
+    }
+
+    findTemplateByPath(path)
+    {
+        if('/' === path){
+            path = '/index';
+        }
+        let templatePath = path.endsWith('/')
+            ? path.slice(0, -1)
+            : path;
+        templatePath = templatePath.startsWith('/')
+            ? templatePath.substring(1)
+            : templatePath;
+        let fullPath = FileHandler.joinPaths(this.templatesPath, templatePath + '.html');
+        if(FileHandler.exists(fullPath)){
+            return fullPath;
+        }
+        return false;
+    }
+
+    async renderContentFromRoute(res, route)
+    {
+        if(!route.router || !route.content_id){
+            return await this.renderNotFoundPage(res);
+        }
+        let entity = this.dataServer.getEntity(route.router);
+        if(!entity){
+            return await this.renderNotFoundPage(res);
+        }
+        let content = await entity.loadById(route.content_id);
+        if(!content){
+            return await this.renderNotFoundPage(res);
+        }
+        let templateName = content.template || route.router;
+        let templatePath = FileHandler.joinPaths(this.templatesPath, templateName + '.html');
+        if(!FileHandler.exists(templatePath)){
+            templatePath = FileHandler.joinPaths(this.templatesPath, 'page.html');
+            if(!FileHandler.exists(templatePath)){
+                return await this.renderNotFoundPage(res);
+            }
+        }
+        let template = FileHandler.readFile(templatePath, {
+            encoding: this.encoding
+        }).toString();
+        let data = {
+            ...route,
+            ...content,
+            current_year: new Date().getFullYear()
+        };
+        let rendered = mustache.render(template, data);
+        return res.send(rendered);
+    }
+
+    async renderContentFromEntity(res, entity, entityName)
+    {
+        let templatePath = FileHandler.joinPaths(this.templatesPath, entityName + '.html');
+        if(!FileHandler.exists(templatePath)){
+            templatePath = FileHandler.joinPaths(this.templatesPath, 'page.html');
+            if(!FileHandler.exists(templatePath)){
+                return await this.renderNotFoundPage(res);
+            }
+        }
+        let template = FileHandler.readFile(templatePath, {
+            encoding: this.encoding
+        }).toString();
+        let data = {
+            ...entity,
+            title: entity.title || entity.name || entityName,
+            current_year: new Date().getFullYear()
+        };
+        let rendered = mustache.render(template, data);
+        return res.send(rendered);
+    }
+
+    async renderTemplateOnly(res, templatePath)
+    {
+        let template = FileHandler.readFile(templatePath, {
+            encoding: this.encoding
+        }).toString();
+        let data = {
+            title: 'Page Title',
+            current_year: new Date().getFullYear()
+        };
+        let rendered = mustache.render(template, data);
+        return res.send(rendered);
+    }
+
+    async renderNotFoundPage(res)
+    {
+        let templatePath = FileHandler.joinPaths(this.templatesPath, '404.html');
+        if(!FileHandler.exists(templatePath)){
+            return res.status(404).send('Page not found');
+        }
+        let template = FileHandler.readFile(templatePath, {
+            encoding: this.encoding
+        }).toString();
+        let data = {
+            title: '404 - Page Not Found',
+            current_year: new Date().getFullYear()
+        };
+        let rendered = mustache.render(template, data);
+        return res.status(404).send(rendered);
+    }
+
+}
+
+module.exports.Storefront = Storefront;

package/lib/templates-list.js

@@ -0,0 +1,50 @@
+/**
+ *
+ * Reldens - TemplatesList
+ *
+ */
+
+module.exports.TemplatesList = {
+    login: 'login.html',
+    dashboard: 'dashboard.html',
+    management: 'management.html',
+    mapsWizard: 'maps-wizard.html',
+    mapsWizardMapsSelection: 'maps-wizard-maps-selection.html',
+    objectsImport: 'objects-import.html',
+    skillsImport: 'skills-import.html',
+    list: 'list.html',
+    listContent: 'list-content.html',
+    view: 'view.html',
+    edit: 'edit.html',
+    layout: 'layout.html',
+    sideBar: 'sidebar.html',
+    sideBarHeader: 'sidebar-header.html',
+    sideBarItem: 'sidebar-item.html',
+    paginationLink: 'pagination-link.html',
+    defaultCopyRight: 'default-copyright.html',
+    fields: {
+        view: {
+            text: 'text.html',
+            image: 'image.html',
+            images: 'images.html',
+            link: 'link.html',
+            links: 'links.html',
+            boolean: 'boolean.html'
+        },
+        edit: {
+            text: 'text.html',
+            textarea: 'textarea.html',
+            select: 'select.html',
+            checkbox: 'checkbox.html',
+            boolean: 'checkbox.html',
+            radio: 'radio.html',
+            button: 'button.html',
+            file: 'file.html'
+        }
+    },
+    sections: {
+        view: {
+            rooms: 'rooms.html'
+        }
+    }
+};

package/migrations/default-user.sql

@@ -0,0 +1,11 @@
+
+-- Default admin user:
+
+INSERT IGNORE INTO `users` (`email`, `username`, `password`, `role_id`, `status`)
+VALUES (
+   'root@cms-admin.com',
+   'root',
+   'd35ed1c81c3ff00de15309fe40a90c32:a39a9231a69fefef274c13c1780a7447672a5fee8250ce22a51bb20275039dda63a54faa1e5fd775becb3ac424f571d5b996001305bb7d63e038111dce08d45b',
+   99,
+   '1'
+);

package/migrations/install.sql

@@ -0,0 +1,84 @@
+
+-- Install SQL for Reldens CMS
+
+CREATE TABLE IF NOT EXISTS `users` (
+    `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
+    `email` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+    `username` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+    `password` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+    `role_id` INT(10) UNSIGNED NOT NULL,
+    `status` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT 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 `email` (`email`) USING BTREE,
+    UNIQUE KEY `username` (`username`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+CREATE TABLE IF NOT EXISTS `routes` (
+    `id` INT(10) 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(10) 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',
+    `cache_ttl_seconds` INT UNSIGNED NULL DEFAULT 3600,
+    `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
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+CREATE TABLE IF NOT EXISTS `cms_pages_meta` (
+    `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
+    `page_id` INT(10) UNSIGNED NOT NULL,
+    `layout` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
+    `publish_date` TIMESTAMP NULL,
+    `expire_date` TIMESTAMP NULL,
+    `author_id` INT(10) UNSIGNED 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
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+CREATE TABLE IF NOT EXISTS `cms_pages` (
+    `id` INT(10) 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,
+    `markdown` LONGTEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
+    `json_data` JSON NULL,
+    `template` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,
+    `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(10) UNSIGNED NOT NULL AUTO_INCREMENT,
+    `entity_name` VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+    `entity_id` INT(10) 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,
+    `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
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- Create a default homepage route if not exists
+INSERT IGNORE 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>', 'page', NOW());
+
+-- Create a default route to the homepage
+INSERT IGNORE INTO `routes` (`path`, `router`, `content_id`, `title`, `meta_description`, `status`, `created_at`) VALUES
+('/home', 'cms_pages', 1, 'Home', 'Welcome to Reldens CMS', 'published', NOW());

package/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "@reldens/cms",
+    "scope": "@reldens",
+    "version": "0.1.0",
+    "description": "Reldens - CMS",
+    "author": "Damian A. Pastorini",
+    "license": "MIT",
+    "homepage": "https://github.com/damian-pastorini/reldens-cms",
+    "source": true,
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "main": "index.js",
+    "bin": {
+        "reldens-cms": "./bin/reldens-cms"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/damian-pastorini/reldens-cms.git"
+    },
+    "keywords": [
+        "reldens",
+        "cms",
+        "system",
+        "content",
+        "management",
+        "dwd",
+        "nodejs",
+        "platform",
+        "framework"
+    ],
+    "bugs": {
+        "url": "https://github.com/damian-pastorini/reldens-cms/issues"
+    },
+    "dependencies": {
+        "@reldens/server-utils": "^0.16.0",
+        "@reldens/storage": "^0.34.0",
+        "@reldens/utils": "^0.47.0",
+        "dotenv": "^16.0.3",
+        "mustache": "^4.2.0"
+    }
+}

package/templates/.env.dist

@@ -0,0 +1,16 @@
+# Database Configuration
+RELDENS_CMS_DB_CLIENT={{dbClient}}
+RELDENS_CMS_DB_HOST={{dbHost}}
+RELDENS_CMS_DB_PORT={{dbPort}}
+RELDENS_CMS_DB_NAME={{dbName}}
+RELDENS_CMS_DB_USER={{dbUser}}
+RELDENS_CMS_DB_PASSWORD={{dbPassword}}
+RELDENS_CMS_DB_DRIVER={{dbDriver}}
+
+# Admin Panel Configuration
+RELDENS_CMS_ADMIN_PATH={{adminPath}}
+RELDENS_CMS_ADMIN_SECRET={{adminSecret}}
+
+# Server Configuration
+RELDENS_CMS_HOST={{host}}
+RELDENS_CMS_PORT={{port}}

package/templates/404.html

@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>404 - Page Not Found</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
+    <link rel="stylesheet" href="/css/styles.css">
+    <script src="/js/scripts.js"></script>
+</head>
+<body>
+<header>
+    <div class="container">
+        <h1>Reldens CMS</h1>
+        <nav>
+            <a href="/">Home</a>
+        </nav>
+    </div>
+</header>
+<div class="container">
+    <main class="error-container">
+        <h1>404 - Page Not Found</h1>
+        <p>The page you are looking for might have been removed, had its name changed, or is temporarily unavailable.</p>
+        <a href="/" class="button">Return to Homepage</a>
+    </main>
+</div>
+<footer>
+    <p>&copy; {{current_year}} - Built with Reldens CMS</p>
+</footer>
+</body>
+</html>
+