@reldens/cms 0.47.0 → 0.49.0

package/bin/reldens-cms-update-password.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ *
+ * Reldens - CMS - Update Password CLI
+ *
+ */
+
+const { Manager } = require('../index');
+const { EntitiesLoader } = require('../lib/entities-loader');
+const { Logger, sc } = require('@reldens/utils');
+const { FileHandler, Encryptor } = require('@reldens/server-utils');
+const dotenv = require('dotenv');
+const readline = require('readline');
+
+class CmsPasswordUpdater
+{
+
+    constructor()
+    {
+        this.args = process.argv.slice(2);
+        this.projectRoot = process.cwd();
+        this.config = {};
+        this.parseArguments();
+    }
+
+    parseArguments()
+    {
+        for(let i = 0; i < this.args.length; i++){
+            let arg = this.args[i];
+            if(!arg.startsWith('--')){
+                continue;
+            }
+            let equalIndex = arg.indexOf('=');
+            if(-1 === equalIndex){
+                let flag = arg.substring(2);
+                if('help' === flag || 'h' === flag){
+                    this.config[flag] = true;
+                }
+                continue;
+            }
+            let key = arg.substring(2, equalIndex);
+            let value = arg.substring(equalIndex + 1);
+            this.config[key] = value;
+        }
+    }
+
+    shouldShowHelp()
+    {
+        return 0 === this.args.length || sc.get(this.config, 'help', false) || sc.get(this.config, 'h', false);
+    }
+
+    showHelp()
+    {
+        Logger.info('');
+        Logger.info('Reldens CMS Password Updater');
+        Logger.info('============================');
+        Logger.info('');
+        Logger.info('Usage: npx reldens-cms-update-password [options]');
+        Logger.info('');
+        Logger.info('Options:');
+        Logger.info('  --email=[email]                  User email address');
+        Logger.info('  --username=[username]            User username');
+        Logger.info('  --password=[password]            New password (prompted if not provided)');
+        Logger.info('  --help, -h                       Show this help message');
+        Logger.info('');
+        Logger.info('Examples:');
+        Logger.info('  npx reldens-cms-update-password --email=admin@example.com');
+        Logger.info('  npx reldens-cms-update-password --username=admin');
+        Logger.info('  npx reldens-cms-update-password --email=admin@example.com --password=newpass123');
+        Logger.info('');
+        Logger.info('Note: You must provide either --email or --username to identify the user.');
+        Logger.info('Note: The tool uses the storage driver configured in your .env file (RELDENS_STORAGE_DRIVER).');
+        Logger.info('');
+    }
+
+    get email()
+    {
+        return sc.get(this.config, 'email', null);
+    }
+
+    get username()
+    {
+        return sc.get(this.config, 'username', null);
+    }
+
+    get password()
+    {
+        return sc.get(this.config, 'password', null);
+    }
+
+    async run()
+    {
+        if(this.shouldShowHelp()){
+            this.showHelp();
+            return true;
+        }
+        if(!this.email && !this.username){
+            Logger.error('Error: You must provide either --email or --username to identify the user.');
+            Logger.info('Run with --help for usage information.');
+            return false;
+        }
+        let newPassword = this.password;
+        if(!newPassword){
+            newPassword = await this.promptPassword();
+            if(!newPassword){
+                Logger.error('Error: Password cannot be empty.');
+                return false;
+            }
+        }
+        let envFilePath = FileHandler.joinPaths(this.projectRoot, '.env');
+        dotenv.config({path: envFilePath});
+        let storageDriver = process.env.RELDENS_STORAGE_DRIVER || 'prisma';
+        Logger.debug('Using storage driver: '+storageDriver);
+        let entitiesLoader = new EntitiesLoader({projectRoot: this.projectRoot});
+        let loadedEntities = entitiesLoader.loadEntities(storageDriver);
+        if(!loadedEntities || !loadedEntities.rawRegisteredEntities){
+            Logger.error('Failed to load entities for driver: '+storageDriver);
+            Logger.error('Make sure you have run "npx reldens-cms-generate-entities" first.');
+            return false;
+        }
+        Logger.debug('Loaded entities for driver: '+storageDriver);
+        let managerConfig = {
+            projectRoot: this.projectRoot,
+            rawRegisteredEntities: loadedEntities.rawRegisteredEntities,
+            entitiesConfig: loadedEntities.entitiesConfig,
+            entitiesTranslations: loadedEntities.entitiesTranslations
+        };
+        if('prisma' === storageDriver){
+            let prismaClient = this.loadPrismaClient();
+            if(prismaClient){
+                managerConfig.prismaClient = prismaClient;
+                Logger.debug('Prisma client loaded and configured.');
+            }
+        }
+        let manager = new Manager(managerConfig);
+        if(!manager.isInstalled()){
+            Logger.error('CMS is not installed. Please run installation first.');
+            return false;
+        }
+        Logger.debug('Reldens CMS Manager instance created for password update.');
+        let initResult = await manager.initializeDataServer();
+        if(!initResult){
+            Logger.error('Failed to initialize data server.');
+            return false;
+        }
+        Logger.debug('Data server initialized successfully.');
+        let success = await this.updateUserPassword(manager.dataServer, newPassword);
+        if(!success){
+            Logger.error('Password update failed.');
+            return false;
+        }
+        Logger.info('Password updated successfully!');
+        return true;
+    }
+
+    loadPrismaClient()
+    {
+        let clientPath = FileHandler.joinPaths(this.projectRoot, 'prisma', 'client');
+        if(!FileHandler.exists(clientPath)){
+            Logger.debug('Prisma client path not found: '+clientPath);
+            return false;
+        }
+        try {
+            let { PrismaClient } = require(clientPath);
+            return new PrismaClient();
+        } catch(error) {
+            Logger.error('Failed to load Prisma client: '+error.message);
+            return false;
+        }
+    }
+
+    async promptPassword()
+    {
+        let rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        return new Promise((resolve) => {
+            rl.question('Enter new password: ', (password) => {
+                rl.question('Confirm new password: ', (confirmPassword) => {
+                    rl.close();
+                    if(password !== confirmPassword){
+                        Logger.error('Passwords do not match.');
+                        resolve(null);
+                        return;
+                    }
+                    resolve(password);
+                });
+            });
+        });
+    }
+
+    async updateUserPassword(dataServer, newPassword)
+    {
+        let usersEntity = dataServer.getEntity('users');
+        if(!usersEntity){
+            Logger.error('Users entity not found.');
+            return false;
+        }
+        let user = null;
+        if(this.email){
+            Logger.info('Looking up user by email: '+this.email);
+            user = await usersEntity.loadOneBy('email', this.email);
+        }
+        if(!user && this.username){
+            Logger.info('Looking up user by username: '+this.username);
+            user = await usersEntity.loadOneBy('username', this.username);
+        }
+        if(!user){
+            Logger.error('User not found with provided credentials.');
+            return false;
+        }
+        Logger.info('User found: '+user.email+' ('+user.username+')');
+        let encryptedPassword = Encryptor.encryptPassword(newPassword);
+        if(!encryptedPassword){
+            Logger.error('Failed to encrypt password.');
+            return false;
+        }
+        Logger.debug('Password encrypted successfully.');
+        try {
+            let updateResult = await usersEntity.updateById(user.id, {password: encryptedPassword});
+            if(!updateResult){
+                Logger.error('Failed to update password in database.');
+                return false;
+            }
+            Logger.info('Password updated in database for user: '+user.email);
+            return true;
+        } catch(error) {
+            Logger.error('Error updating password: '+error.message);
+            return false;
+        }
+    }
+
+}
+
+let updater = new CmsPasswordUpdater();
+updater.run().then((success) => {
+    if(!success){
+        process.exit(1);
+    }
+    process.exit(0);
+}).catch((error) => {
+    Logger.critical('Error during password update: '+error.message);
+    process.exit(1);
+});

package/lib/admin-manager/router-contents.js

@@ -33,6 +33,7 @@ class RouterContents
         this.fetchUploadProperties = props.fetchUploadProperties;
         this.uploaderFactory = props.uploaderFactory;
         this.filtersManager = new AdminFiltersManager();
+        this.passwordFieldNames = props.passwordFieldNames || ['password'];
     }
 
     async generateListRouteContent(req, driverResource, entityPath)
@@ -220,7 +221,7 @@ class RouterContents
                     fieldDisabled: fieldDisabled ? ' disabled="disabled"' : '',
                     required: (!property.isUpload || !loadedEntity) && property.isRequired ? ' required="required"' : '',
                     multiple: property.isArray ? ' multiple="multiple"' : '',
-                    inputType: this.getInputType(property, fieldDisabled)
+                    inputType: this.getInputType(property, propertyKey, fieldDisabled)
                 }
             );
         }
@@ -512,6 +513,11 @@ class RouterContents
                 );
                 return false;
             }
+            if(-1 !== this.passwordFieldNames.indexOf(i)){
+                if(!propertyUpdateValue || '' === propertyUpdateValue){
+                    continue;
+                }
+            }
             if(!property.isUpload || (property.isUpload && !isNull)){
                 entityDataPatch[i] = propertyUpdateValue;
             }
@@ -597,6 +603,9 @@ class RouterContents
 
     async generatePropertyEditRenderedValue(entity, propertyKey, resourceProperty)
     {
+        if(-1 !== this.passwordFieldNames.indexOf(propertyKey)){
+            return '';
+        }
         let entityPropertyValue = sc.get(entity, propertyKey, null);
         let fieldValue = (0 === entityPropertyValue ? '0' : entityPropertyValue || '');
         if('null' === fieldValue){
@@ -693,8 +702,11 @@ class RouterContents
         return propertyType;
     }
 
-    getInputType(resourceProperty, fieldDisabled)
+    getInputType(resourceProperty, propertyKey, fieldDisabled)
     {
+        if(-1 !== this.passwordFieldNames.indexOf(propertyKey) && !fieldDisabled){
+            return 'password';
+        }
         if('datetime' === resourceProperty.type && !fieldDisabled){
             return 'datetime-local';
         }

package/lib/admin-manager/router.js

@@ -84,6 +84,7 @@ class Router
                 req.session.user = loginResult;
                 return res.redirect(this.rootPath);
             }
+            Logger.error('Admin authentication failed.', {email, adminRoleId: this.adminRoleId});
             return res.redirect(this.rootPath+this.loginPath+'?login-error=true');
         });
         this.adminRouter.get('/', this.isAuthenticated.bind(this), async (req, res) => {

package/lib/manager.js

@@ -19,6 +19,7 @@ const { Installer } = require('./installer');
 const { Frontend } = require('./frontend');
 const { CacheManager } = require('./cache/cache-manager');
 const { TemplateReloader } = require('./template-reloader');
+const { PasswordEncryptionHandler } = require('./password-encryption-handler');
 const { EventsManagerSingleton, Logger, sc } = require('@reldens/utils');
 const { DriversMap } = require('@reldens/storage');
 const { AppServerFactory, FileHandler, Encryptor } = require('@reldens/server-utils');
@@ -44,6 +45,7 @@ class Manager
         this.entityAccess = sc.get(props, 'entityAccess', {});
         this.authenticationMethod = sc.get(props, 'authenticationMethod', 'db-users');
         this.authenticationCallback = sc.get(props, 'authenticationCallback', false);
+        this.enablePasswordEncryption = sc.get(props, 'enablePasswordEncryption', true);
         this.events = sc.get(props, 'events', EventsManagerSingleton);
         this.adminTemplatesList = sc.get(props, 'adminTemplatesList', TemplatesList);
         this.projectAdminPath = FileHandler.joinPaths(this.projectRoot, 'admin');
@@ -86,6 +88,7 @@ class Manager
         this.developmentPorts = sc.get(props, 'developmentPorts', []);
         this.developmentMultiplier = sc.get(props, 'developmentMultiplier', 10);
         this.appServerConfig = sc.get(props, 'appServerConfig', {});
+        this.useDefaultErrorCallback = sc.get(props, 'useDefaultErrorCallback', true);
         this.developmentExternalDomains = sc.get(props, 'developmentExternalDomains', {});
         this.appServerFactory = new AppServerFactory();
         this.adminEntitiesGenerator = new AdminEntitiesGenerator();
@@ -250,6 +253,34 @@ class Manager
             developmentMultiplier: this.developmentMultiplier,
             developmentExternalDomains: this.developmentExternalDomains
         };
+        if(this.useDefaultErrorCallback && !this.appServerConfig.onError){
+            baseConfig.onError = (event) => {
+                if(!event.error){
+                    return;
+                }
+                let errorKey = event.key || 'unknown';
+                let errorMessage = 'string' === typeof event.error ? event.error : event.error.message;
+                let errorCode = event.error.code || '';
+                let errorStack = event.error.stack || '';
+                let logParts = ['Server error - key: '+errorKey];
+                if(event.hostname){
+                    logParts.push('hostname: '+event.hostname);
+                }
+                if(event.path){
+                    logParts.push('path: '+event.path);
+                }
+                if(errorCode){
+                    logParts.push('code: '+errorCode);
+                }
+                if(errorMessage){
+                    logParts.push('message: '+errorMessage);
+                }
+                if(errorStack){
+                    logParts.push('stack: '+errorStack);
+                }
+                Logger.error(logParts.join(', '));
+            };
+        }
         let appServerConfig = Object.assign({}, baseConfig, this.appServerConfig);
         if(this.domainMapping && 'object' === typeof this.domainMapping){
             this.appServerFactory.setDomainMapping(this.domainMapping);
@@ -283,17 +314,32 @@ class Manager
                 +'Add CDN domains to developmentExternalDomains configuration.');
             return;
         }
-        let cdnUrls = Object.keys(this.domainCdnMapping).map(domain => this.domainCdnMapping[domain]);
-        let missingCDNs = [];
-        for(let cdnUrl of cdnUrls){
+        let domainKeys = Object.keys(this.domainCdnMapping);
+        let domainsWithMissingCdn = [];
+        for(let domain of domainKeys){
+            let cdnUrl = this.domainCdnMapping[domain];
             let cdnHostname = cdnUrl.replace(/^https?:\/\//, '').split('/')[0];
-            if(!sc.hasOwn(this.developmentExternalDomains, cdnHostname)){
-                missingCDNs.push(cdnHostname);
+            let cdnUrlWithProtocol = cdnUrl.split('/')[0];
+            let foundInDirective = false;
+            let directiveKeys = Object.keys(this.developmentExternalDomains);
+            for(let directiveKey of directiveKeys){
+                let domains = this.developmentExternalDomains[directiveKey];
+                if(!sc.isArray(domains)){
+                    continue;
+                }
+                if(domains.includes(cdnUrlWithProtocol) || domains.includes(cdnHostname)){
+                    foundInDirective = true;
+                    break;
+                }
+            }
+            if(!foundInDirective){
+                domainsWithMissingCdn.push(domain);
             }
         }
-        if(0 < missingCDNs.length){
-            Logger.info('CDN domains not found in developmentExternalDomains: '+missingCDNs.join(', ')
-                +'. Add them to avoid CORS issues in development mode.');
+        if(0 < domainsWithMissingCdn.length){
+            Logger.info('CDN mapping for domains: '+domainsWithMissingCdn.join(', ')
+                +' not found in CSP directives (scriptSrc, styleSrc, fontSrc, imgSrc, connectSrc, manifestSrc) '
+                +'within developmentExternalDomains. Add CDN URLs to avoid CORS issues in development mode.');
         }
     }
 
@@ -499,6 +545,7 @@ class Manager
             adminFilesContents,
             translations
         });
+        this.initializePasswordEncryptionHandler();
         let adminConfig = {
             events: this.events,
             dataServer: this.dataServer,
@@ -535,6 +582,21 @@ class Manager
         return true;
     }
 
+    initializePasswordEncryptionHandler()
+    {
+        if(!this.enablePasswordEncryption){
+            Logger.debug('Password encryption handler is disabled.');
+            return false;
+        }
+        this.passwordEncryptionHandler = new PasswordEncryptionHandler({
+            events: this.events,
+            enabled: this.enablePasswordEncryption
+        });
+        this.passwordEncryptionHandler.registerEventListeners();
+        Logger.debug('Password encryption handler initialized and registered.');
+        return true;
+    }
+
     async initializeCmsPagesRouteManager()
     {
         if(!this.dataServer){

package/lib/password-encryption-handler.js

@@ -0,0 +1,94 @@
+/**
+ *
+ * Reldens - CMS - Password Encryption Handler
+ *
+ */
+
+const { Encryptor } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+
+class PasswordEncryptionHandler
+{
+
+    constructor(props)
+    {
+        this.events = sc.get(props, 'events', false);
+        this.entityKey = sc.get(props, 'entityKey', 'users');
+        this.passwordField = sc.get(props, 'passwordField', 'password');
+        this.enabled = sc.get(props, 'enabled', true);
+        if(!this.events){
+            Logger.warning('PasswordEncryptionHandler: No events manager provided, handler will not be active.');
+            this.enabled = false;
+        }
+    }
+
+    registerEventListeners()
+    {
+        if(!this.enabled){
+            Logger.debug('PasswordEncryptionHandler is disabled, skipping event registration.');
+            return false;
+        }
+        this.events.on('reldens.adminBeforeEntitySave', async (eventData) => {
+            await this.handleBeforeEntitySave(eventData);
+        });
+        Logger.debug('PasswordEncryptionHandler registered for event: reldens.adminBeforeEntitySave');
+        return true;
+    }
+
+    async handleBeforeEntitySave(eventData)
+    {
+        let driverResource = sc.get(eventData, 'driverResource', false);
+        if(!driverResource){
+            return;
+        }
+        if(driverResource.entityKey !== this.entityKey){
+            return;
+        }
+        let req = sc.get(eventData, 'req', false);
+        if(!req){
+            return;
+        }
+        let passwordValue = sc.get(req.body, this.passwordField, null);
+        if(!passwordValue){
+            return;
+        }
+        if('' === passwordValue){
+            return;
+        }
+        if(this.isAlreadyEncrypted(passwordValue)){
+            Logger.debug('Password field appears to be already encrypted, skipping encryption.');
+            return;
+        }
+        Logger.debug('Encrypting password for user entity save.');
+        let encryptedPassword = Encryptor.encryptPassword(passwordValue);
+        if(!encryptedPassword){
+            Logger.error('Failed to encrypt password for user entity save.');
+            return;
+        }
+        req.body[this.passwordField] = encryptedPassword;
+        Logger.debug('Password encrypted successfully for user entity save.');
+    }
+
+    isAlreadyEncrypted(value)
+    {
+        if(!sc.isString(value)){
+            return false;
+        }
+        let parts = value.split(':');
+        if(2 !== parts.length){
+            return false;
+        }
+        let saltLength = parts[0].length;
+        let hashLength = parts[1].length;
+        if(64 !== saltLength){
+            return false;
+        }
+        if(128 !== hashLength){
+            return false;
+        }
+        return true;
+    }
+
+}
+
+module.exports.PasswordEncryptionHandler = PasswordEncryptionHandler;

package/lib/template-engine.js

@@ -30,9 +30,15 @@ class TemplateEngine
         this.defaultDomain = sc.get(props, 'defaultDomain', 'default');
         this.projectRoot = sc.get(props, 'projectRoot', './');
         this.publicPath = sc.get(props, 'publicPath', './public');
-        this.domainPublicUrlMapping = sc.isObject(props.domainPublicUrlMapping) && !sc.isArray(props.domainPublicUrlMapping) ? props.domainPublicUrlMapping : {};
+        this.domainPublicUrlMapping = sc.isObject(props.domainPublicUrlMapping)
+            && !sc.isArray(props.domainPublicUrlMapping)
+            ? props.domainPublicUrlMapping
+            : {};
         this.defaultPublicUrl = sc.get(props, 'defaultPublicUrl', '');
-        this.domainCdnMapping = sc.isObject(props.domainCdnMapping) && !sc.isArray(props.domainCdnMapping) ? props.domainCdnMapping : {};
+        this.domainCdnMapping = sc.isObject(props.domainCdnMapping)
+            && !sc.isArray(props.domainCdnMapping)
+            ? props.domainCdnMapping
+            : {};
         this.dynamicForm = sc.get(props, 'dynamicForm', false);
         this.dynamicFormRenderer = sc.get(props, 'dynamicFormRenderer', false);
         this.jsonFieldsParser = new JsonFieldsParser({entitiesConfig: sc.get(props, 'entitiesConfig', {})});

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/cms",
     "scope": "@reldens",
-    "version": "0.47.0",
+    "version": "0.49.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -12,7 +12,8 @@
     },
     "bin": {
         "reldens-cms": "bin/reldens-cms.js",
-        "reldens-cms-generate-entities": "bin/reldens-cms-generate-entities.js"
+        "reldens-cms-generate-entities": "bin/reldens-cms-generate-entities.js",
+        "reldens-cms-update-password": "bin/reldens-cms-update-password.js"
     },
     "repository": {
         "type": "git",
@@ -33,8 +34,8 @@
         "url": "https://github.com/damian-pastorini/reldens-cms/issues"
     },
     "dependencies": {
-        "@reldens/server-utils": "^0.42.0",
-        "@reldens/storage": "^0.84.0",
+        "@reldens/server-utils": "^0.43.0",
+        "@reldens/storage": "^0.85.0",
         "@reldens/utils": "^0.54.0",
         "dotenv": "17.2.3",
         "mustache": "4.2.0"

package/templates/.env.dist

@@ -1,11 +1,11 @@
 # Database Configuration
+RELDENS_STORAGE_DRIVER={{&dbDriver}}
 RELDENS_DB_CLIENT={{&dbClient}}
 RELDENS_DB_HOST={{&dbHost}}
 RELDENS_DB_PORT={{&dbPort}}
 RELDENS_DB_NAME={{&dbName}}
 RELDENS_DB_USER={{&dbUser}}
 RELDENS_DB_PASSWORD={{&dbPassword}}
-RELDENS_DB_DRIVER={{&dbDriver}}
 RELDENS_DB_URL={{&dbClient}}://{{&dbUser}}:{{&dbPassword}}@{{&dbHost}}:{{&dbPort}}/{{&dbName}}
 
 # Admin Panel Configuration

package/templates/page.html

@@ -7,19 +7,24 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=5.0, user-scalable=yes, viewport-fit=cover"/>
     <meta name="robots" content="{{meta_robots}}">
     <meta name="theme-color" content="{{meta_theme_color}}"/>
+    <meta property="og:title" content="{{meta_og_title}}"/>
+    <meta property="og:type" content="website"/>
+    <meta property="og:site_name" content="{{siteHandle}}"/>
+    <meta property="og:url" content="{{currentRequest.fullUrl}}"/>
+    <meta property="og:locale" content="{{locale}}"/>
     {{#meta_description}}
     <meta name="description" content="{{meta_description}}"/>
+    <meta property="og:description" content="{{meta_description}}"/>
     {{/meta_description}}
-    <meta property="og:title" content="{{meta_og_title}}"/>
-    {{#meta_og_description}}
-    <meta property="og:description" content="{{meta_og_description}}"/>
-    {{/meta_og_description}}
     {{#meta_og_image}}
     <meta property="og:image" content="{{meta_og_image}}"/>
     {{/meta_og_image}}
     {{#meta_twitter_card_type}}
     <meta name="twitter:card" content="{{meta_twitter_card_type}}"/>
     {{/meta_twitter_card_type}}
+    {{#article_author}}
+    <meta property="article:author" content="{{article_author}}"/>
+    {{/article_author}}
     {{#publish_date}}
     <meta name="publish-date" content="{{publish_date}}"/>
     {{/publish_date}}
@@ -34,14 +39,13 @@
     <link rel="icon" href="[asset(/favicons/default/favicon.ico)]" type="image/x-icon"/>
     <link rel="shortcut icon" href="[asset(/favicons/default/favicon.ico)]" type="image/x-icon">
     <link rel="manifest" href="[asset(/favicons/default/site.webmanifest)]"/>
-    <!-- CSS and JS -->
-    <link rel="stylesheet" href="[url(/css/styles.css)]"/>
-    <script defer src="[url(/js/cookie-consent.js)]"></script>
+    <link rel="stylesheet" href="[cdn(/css/styles.css)]"/>
 </head>
 <body class="{{siteHandle}}">
-{{&content}}
-{{>cookie-consent}}
-<script defer type="text/javascript" src="[url(/js/functions.js)]"></script>
-<script defer type="text/javascript" src="[url(/js/scripts.js)]"></script>
+    {{&content}}
+    {{>cookie-consent}}
+    <script defer type="text/javascript" src="[cdn(/js/functions.js)]"></script>
+    <script defer type="text/javascript" src="[cdn(/js/scripts.js)]"></script>
+    <script defer src="[cdn(/js/cookie-consent.js)]"></script>
 </body>
 </html>