ghost 6.8.0 → 6.9.0

package/core/server/services/email-service/EmailEventProcessor.js

@@ -65,9 +65,10 @@ class EmailEventProcessor {
     /**
      * @param {EmailIdentification} emailIdentification
      * @param {Date} timestamp
+     * @param {Map<string, EmailRecipientInformation>} [recipientCache] Optional cache for batched processing
      */
-    async handleDelivered(emailIdentification, timestamp) {
-        const recipient = await this.getRecipient(emailIdentification);
+    async handleDelivered(emailIdentification, timestamp, recipientCache) {
+        const recipient = await this.getRecipient(emailIdentification, recipientCache);
         if (recipient) {
             const event = EmailDeliveredEvent.create({
                 email: emailIdentification.email,
@@ -87,9 +88,10 @@ class EmailEventProcessor {
     /**
      * @param {EmailIdentification} emailIdentification
      * @param {Date} timestamp
+     * @param {Map<string, EmailRecipientInformation>} [recipientCache] Optional cache for batched processing
      */
-    async handleOpened(emailIdentification, timestamp) {
-        const recipient = await this.getRecipient(emailIdentification);
+    async handleOpened(emailIdentification, timestamp, recipientCache) {
+        const recipient = await this.getRecipient(emailIdentification, recipientCache);
         if (recipient) {
             const event = EmailOpenedEvent.create({
                 email: emailIdentification.email,
@@ -108,9 +110,10 @@ class EmailEventProcessor {
     /**
      * @param {EmailIdentification} emailIdentification
      * @param {{id: string, timestamp: Date, error: {code: number; message: string; enhandedCode: string|number} | null}} event
+     * @param {Map<string, EmailRecipientInformation>} [recipientCache] Optional cache for batched processing
      */
-    async handleTemporaryFailed(emailIdentification, {timestamp, error, id}) {
-        const recipient = await this.getRecipient(emailIdentification);
+    async handleTemporaryFailed(emailIdentification, {timestamp, error, id}, recipientCache) {
+        const recipient = await this.getRecipient(emailIdentification, recipientCache);
         if (recipient) {
             const event = EmailTemporaryBouncedEvent.create({
                 id,
@@ -131,9 +134,10 @@ class EmailEventProcessor {
     /**
      * @param {EmailIdentification} emailIdentification
      * @param {{id: string, timestamp: Date, error: {code: number; message: string; enhandedCode: string|number} | null}} event
+     * @param {Map<string, EmailRecipientInformation>} [recipientCache] Optional cache for batched processing
      */
-    async handlePermanentFailed(emailIdentification, {timestamp, error, id}) {
-        const recipient = await this.getRecipient(emailIdentification);
+    async handlePermanentFailed(emailIdentification, {timestamp, error, id}, recipientCache) {
+        const recipient = await this.getRecipient(emailIdentification, recipientCache);
         if (recipient) {
             const event = EmailBouncedEvent.create({
                 id,
@@ -155,9 +159,10 @@ class EmailEventProcessor {
     /**
      * @param {EmailIdentification} emailIdentification
      * @param {Date} timestamp
+     * @param {Map<string, EmailRecipientInformation>} [recipientCache] Optional cache for batched processing
      */
-    async handleUnsubscribed(emailIdentification, timestamp) {
-        const recipient = await this.getRecipient(emailIdentification);
+    async handleUnsubscribed(emailIdentification, timestamp, recipientCache) {
+        const recipient = await this.getRecipient(emailIdentification, recipientCache);
         if (recipient) {
             const event = EmailUnsubscribedEvent.create({
                 email: emailIdentification.email,
@@ -175,9 +180,10 @@ class EmailEventProcessor {
     /**
      * @param {EmailIdentification} emailIdentification
      * @param {Date} timestamp
+     * @param {Map<string, EmailRecipientInformation>} [recipientCache] Optional cache for batched processing
      */
-    async handleComplained(emailIdentification, timestamp) {
-        const recipient = await this.getRecipient(emailIdentification);
+    async handleComplained(emailIdentification, timestamp, recipientCache) {
+        const recipient = await this.getRecipient(emailIdentification, recipientCache);
         if (recipient) {
             const event = SpamComplaintEvent.create({
                 email: emailIdentification.email,
@@ -196,9 +202,10 @@ class EmailEventProcessor {
     /**
      * @private
      * @param {EmailIdentification} emailIdentification
+     * @param {Map<string, EmailRecipientInformation>} [recipientCache] Optional cache for batched processing
      * @returns {Promise<EmailRecipientInformation|undefined>}
      */
-    async getRecipient(emailIdentification) {
+    async getRecipient(emailIdentification, recipientCache) {
         if (!emailIdentification.emailId && !emailIdentification.providerId) {
             // Protection if both are null or undefined
             return;
@@ -211,6 +218,16 @@ class EmailEventProcessor {
             return;
         }
 
+        // Check cache first if batched processing is enabled
+        if (recipientCache) {
+            const key = `${emailIdentification.email}:${emailId}`;
+            const cached = recipientCache.get(key);
+            if (cached) {
+                return cached;
+            }
+        }
+
+        // Fall back to individual query for backwards compatibility
         const {id: emailRecipientId, member_id: memberId} = await this.#db.knex('email_recipients')
             .select('id', 'member_id')
             .where('member_email', emailIdentification.email)
@@ -262,6 +279,89 @@ class EmailEventProcessor {
         this.providerIdEmailIdMap[providerId] = emailId;
         return emailId;
     }
+
+    /**
+     * Batch lookup recipients for all events
+     * @param {Array<EmailIdentification>} emailIdentifications
+     * @returns {Promise<Map<string, EmailRecipientInformation>>}
+     */
+    async batchGetRecipients(emailIdentifications) {
+        const recipientCache = new Map();
+
+        if (!emailIdentifications || emailIdentifications.length === 0) {
+            return recipientCache;
+        }
+
+        // Step 1: Resolve all providerId -> emailId mappings
+        const providerIds = [...new Set(
+            emailIdentifications
+                .filter(e => e.providerId && !e.emailId)
+                .map(e => e.providerId)
+        )];
+
+        if (providerIds.length > 0) {
+            const providerIdMapping = await this.#db.knex('email_batches')
+                .select('provider_id', 'email_id')
+                .whereIn('provider_id', providerIds);
+
+            for (const row of providerIdMapping) {
+                this.providerIdEmailIdMap[row.provider_id] = row.email_id;
+            }
+        }
+
+        // Step 2: Build list of (email, emailId) pairs to lookup
+        const lookups = [];
+        for (const identification of emailIdentifications) {
+            const emailId = identification.emailId ?? this.providerIdEmailIdMap[identification.providerId];
+            if (emailId && identification.email) {
+                lookups.push({
+                    email: identification.email,
+                    emailId: emailId
+                });
+            }
+        }
+
+        if (lookups.length === 0) {
+            return recipientCache;
+        }
+
+        // Step 3: Batch query all recipients with OR conditions
+        // Build the WHERE clause with OR conditions
+        const recipientQuery = this.#db.knex('email_recipients')
+            .select('id', 'member_id', 'email_id', 'member_email');
+
+        // Add WHERE conditions - need to build complex OR query
+        recipientQuery.where(function () {
+            for (const lookup of lookups) {
+                this.orWhere(function () {
+                    this.where('member_email', lookup.email)
+                        .andWhere('email_id', lookup.emailId);
+                });
+            }
+        });
+
+        const recipients = await recipientQuery;
+
+        // Step 4: Build cache map keyed by "email:emailId"
+        for (const recipient of recipients) {
+            const key = `${recipient.member_email}:${recipient.email_id}`;
+            recipientCache.set(key, {
+                emailRecipientId: recipient.id,
+                memberId: recipient.member_id,
+                emailId: recipient.email_id
+            });
+        }
+
+        return recipientCache;
+    }
+
+    /**
+     * Flush any batched updates to the database
+     * @returns {Promise<void>}
+     */
+    async flushBatchedUpdates() {
+        return await this.#eventStorage.flushBatchedUpdates();
+    }
 }
 
 module.exports = EmailEventProcessor;

package/core/server/services/email-service/EmailEventStorage.js

@@ -1,5 +1,6 @@
 const moment = require('moment-timezone');
 const logging = require('@tryghost/logging');
+const config = require('../../../shared/config');
 
 class EmailEventStorage {
     #db;
@@ -7,6 +8,7 @@ class EmailEventStorage {
     #models;
     #emailSuppressionList;
     #prometheusClient;
+    #pendingUpdates;
 
     constructor({db, models, membersRepository, emailSuppressionList, prometheusClient}) {
         this.#db = db;
@@ -15,6 +17,13 @@ class EmailEventStorage {
         this.#emailSuppressionList = emailSuppressionList;
         this.#prometheusClient = prometheusClient;
 
+        // Initialize pending updates for batched processing
+        this.#pendingUpdates = {
+            delivered: new Map(), // recipientId -> timestamp
+            opened: new Map(), // recipientId -> timestamp
+            failed: new Map() // recipientId -> timestamp
+        };
+
         if (this.#prometheusClient) {
             this.#prometheusClient.registerCounter({
                 name: 'email_analytics_events_stored',
@@ -25,38 +34,80 @@ class EmailEventStorage {
     }
 
     async handleDelivered(event) {
-        // To properly handle events that are received out of order (this happens because of polling)
-        // only set if delivered_at is null
-        const rowCount = await this.#db.knex('email_recipients')
-            .where('id', '=', event.emailRecipientId)
-            .whereNull('delivered_at')
-            .update({
-                delivered_at: moment.utc(event.timestamp).format('YYYY-MM-DD HH:mm:ss')
-            });
-        this.recordEventStored('delivered', rowCount);
+        const useBatchProcessing = config.get('emailAnalytics:batchProcessing');
+
+        if (useBatchProcessing) {
+            // Accumulate update for batch processing
+            const timestamp = moment.utc(event.timestamp).format('YYYY-MM-DD HH:mm:ss');
+            const existing = this.#pendingUpdates.delivered.get(event.emailRecipientId);
+
+            // Keep the earliest timestamp (out-of-order protection)
+            if (!existing || timestamp < existing) {
+                this.#pendingUpdates.delivered.set(event.emailRecipientId, timestamp);
+            }
+        } else {
+            // Sequential mode: immediate update
+            // To properly handle events that are received out of order (this happens because of polling)
+            // only set if delivered_at is null
+            const rowCount = await this.#db.knex('email_recipients')
+                .where('id', '=', event.emailRecipientId)
+                .whereNull('delivered_at')
+                .update({
+                    delivered_at: moment.utc(event.timestamp).format('YYYY-MM-DD HH:mm:ss')
+                });
+            this.recordEventStored('delivered', rowCount);
+        }
     }
 
     async handleOpened(event) {
-        // To properly handle events that are received out of order (this happens because of polling)
-        // only set if opened_at is null
-        const rowCount = await this.#db.knex('email_recipients')
-            .where('id', '=', event.emailRecipientId)
-            .whereNull('opened_at')
-            .update({
-                opened_at: moment.utc(event.timestamp).format('YYYY-MM-DD HH:mm:ss')
-            });
-        this.recordEventStored('opened', rowCount);
+        const useBatchProcessing = config.get('emailAnalytics:batchProcessing');
+
+        if (useBatchProcessing) {
+            // Accumulate update for batch processing
+            const timestamp = moment.utc(event.timestamp).format('YYYY-MM-DD HH:mm:ss');
+            const existing = this.#pendingUpdates.opened.get(event.emailRecipientId);
+
+            // Keep the earliest timestamp (out-of-order protection)
+            if (!existing || timestamp < existing) {
+                this.#pendingUpdates.opened.set(event.emailRecipientId, timestamp);
+            }
+        } else {
+            // Sequential mode: immediate update
+            // To properly handle events that are received out of order (this happens because of polling)
+            // only set if opened_at is null
+            const rowCount = await this.#db.knex('email_recipients')
+                .where('id', '=', event.emailRecipientId)
+                .whereNull('opened_at')
+                .update({
+                    opened_at: moment.utc(event.timestamp).format('YYYY-MM-DD HH:mm:ss')
+                });
+            this.recordEventStored('opened', rowCount);
+        }
     }
 
     async handlePermanentFailed(event) {
-        // To properly handle events that are received out of order (this happens because of polling)
-        // only set if failed_at is null
-        await this.#db.knex('email_recipients')
-            .where('id', '=', event.emailRecipientId)
-            .whereNull('failed_at')
-            .update({
-                failed_at: moment.utc(event.timestamp).format('YYYY-MM-DD HH:mm:ss')
-            });
+        const useBatchProcessing = config.get('emailAnalytics:batchProcessing');
+
+        if (useBatchProcessing) {
+            // Accumulate update for batch processing
+            const timestamp = moment.utc(event.timestamp).format('YYYY-MM-DD HH:mm:ss');
+            const existing = this.#pendingUpdates.failed.get(event.emailRecipientId);
+
+            // Keep the earliest timestamp (out-of-order protection)
+            if (!existing || timestamp < existing) {
+                this.#pendingUpdates.failed.set(event.emailRecipientId, timestamp);
+            }
+        } else {
+            // Sequential mode: immediate update
+            // To properly handle events that are received out of order (this happens because of polling)
+            // only set if failed_at is null
+            await this.#db.knex('email_recipients')
+                .where('id', '=', event.emailRecipientId)
+                .whereNull('failed_at')
+                .update({
+                    failed_at: moment.utc(event.timestamp).format('YYYY-MM-DD HH:mm:ss')
+                });
+        }
         await this.saveFailure('permanent', event);
     }
 
@@ -182,6 +233,120 @@ class EmailEventStorage {
             logging.error('Error recording email analytics event stored', err);
         }
     }
+
+    /**
+     * Flush all batched updates to the database
+     * @returns {Promise<void>}
+     */
+    async flushBatchedUpdates() {
+        const deliveredCount = this.#pendingUpdates.delivered.size;
+        const openedCount = this.#pendingUpdates.opened.size;
+        const failedCount = this.#pendingUpdates.failed.size;
+
+        if (deliveredCount === 0 && openedCount === 0 && failedCount === 0) {
+            return; // Nothing to flush
+        }
+
+        // Flush delivered events
+        if (deliveredCount > 0) {
+            await this.#flushDeliveredUpdates();
+        }
+
+        // Flush opened events
+        if (openedCount > 0) {
+            await this.#flushOpenedUpdates();
+        }
+
+        // Flush failed events
+        if (failedCount > 0) {
+            await this.#flushFailedUpdates();
+        }
+
+        // Clear the pending updates
+        this.#pendingUpdates.delivered.clear();
+        this.#pendingUpdates.opened.clear();
+        this.#pendingUpdates.failed.clear();
+    }
+
+    /**
+     * @private
+     */
+    async #flushDeliveredUpdates() {
+        const updates = Array.from(this.#pendingUpdates.delivered.entries());
+        if (updates.length === 0) {
+            return;
+        }
+
+        // Build CASE statement for batched update
+        const recipientIds = updates.map(([id]) => id);
+        const caseClauses = updates.map(([id, timestamp]) => {
+            return `WHEN '${id}' THEN '${timestamp}'`;
+        }).join(' ');
+
+        const sql = `
+            UPDATE email_recipients
+            SET delivered_at = CASE id ${caseClauses} END
+            WHERE id IN (${recipientIds.map(() => '?').join(',')})
+            AND delivered_at IS NULL
+        `;
+
+        const rowCount = await this.#db.knex.raw(sql, recipientIds);
+        this.recordEventStored('delivered', updates.length);
+        return rowCount;
+    }
+
+    /**
+     * @private
+     */
+    async #flushOpenedUpdates() {
+        const updates = Array.from(this.#pendingUpdates.opened.entries());
+        if (updates.length === 0) {
+            return;
+        }
+
+        // Build CASE statement for batched update
+        const recipientIds = updates.map(([id]) => id);
+        const caseClauses = updates.map(([id, timestamp]) => {
+            return `WHEN '${id}' THEN '${timestamp}'`;
+        }).join(' ');
+
+        const sql = `
+            UPDATE email_recipients
+            SET opened_at = CASE id ${caseClauses} END
+            WHERE id IN (${recipientIds.map(() => '?').join(',')})
+            AND opened_at IS NULL
+        `;
+
+        const rowCount = await this.#db.knex.raw(sql, recipientIds);
+        this.recordEventStored('opened', updates.length);
+        return rowCount;
+    }
+
+    /**
+     * @private
+     */
+    async #flushFailedUpdates() {
+        const updates = Array.from(this.#pendingUpdates.failed.entries());
+        if (updates.length === 0) {
+            return;
+        }
+
+        // Build CASE statement for batched update
+        const recipientIds = updates.map(([id]) => id);
+        const caseClauses = updates.map(([id, timestamp]) => {
+            return `WHEN '${id}' THEN '${timestamp}'`;
+        }).join(' ');
+
+        const sql = `
+            UPDATE email_recipients
+            SET failed_at = CASE id ${caseClauses} END
+            WHERE id IN (${recipientIds.map(() => '?').join(',')})
+            AND failed_at IS NULL
+        `;
+
+        const rowCount = await this.#db.knex.raw(sql, recipientIds);
+        return rowCount;
+    }
 }
 
 module.exports = EmailEventStorage;

package/core/server/services/email-service/EmailRenderer.js

@@ -247,6 +247,12 @@ class EmailRenderer {
         return locale;
     }
 
+    /**
+     * @param {Post} post
+     * @param {Newsletter} newsletter
+     * @param {boolean} [useFallbackAddress]
+     * @returns {string|null}
+     */
     getFromAddress(post, newsletter, useFallbackAddress = false) {
         // Clean from address to ensure DMARC alignment
         const addresses = this.#emailAddressService.getAddress({
@@ -259,9 +265,10 @@ class EmailRenderer {
     /**
      * @param {Post} post
      * @param {Newsletter} newsletter
+     * @param {boolean} [useFallbackAddress]
      * @returns {string|null}
      */
-    getReplyToAddress(post, newsletter) {
+    getReplyToAddress(post, newsletter, useFallbackAddress = false) {
         const replyToAddress = newsletter.get('sender_reply_to');
 
         if (replyToAddress === 'support') {
@@ -269,13 +276,13 @@ class EmailRenderer {
         }
 
         if (replyToAddress === 'newsletter' && !this.#emailAddressService.managedEmailEnabled) {
-            return this.getFromAddress(post, newsletter);
+            return this.getFromAddress(post, newsletter, useFallbackAddress);
         }
 
         const addresses = this.#emailAddressService.getAddress({
             from: this.#getRawFromAddress(post, newsletter),
             replyTo: replyToAddress === 'newsletter' ? undefined : {address: replyToAddress}
-        });
+        }, {useFallbackAddress});
 
         if (addresses.replyTo) {
             return EmailAddressParser.stringify(addresses.replyTo);

package/core/server/services/email-service/SendingService.js

@@ -138,7 +138,7 @@ class SendingService {
         return await this.#emailProvider.send({
             subject: this.#emailRenderer.getSubject(post, isTestEmail),
             from: this.#emailRenderer.getFromAddress(post, newsletter, !!options.useFallbackAddress),
-            replyTo: this.#emailRenderer.getReplyToAddress(post, newsletter) ?? undefined,
+            replyTo: this.#emailRenderer.getReplyToAddress(post, newsletter, !!options.useFallbackAddress) ?? undefined,
             html: emailBody.html,
             plaintext: emailBody.plaintext,
             recipients,

package/core/server/services/lib/MailgunClient.js

@@ -71,7 +71,8 @@ module.exports = class MailgunClient {
                 text: messageContent.plaintext,
                 'recipient-variables': JSON.stringify(recipientData),
                 'h:Sender': message.from,
-                'h:Auto-Submitted': 'auto-generated'
+                'h:Auto-Submitted': 'auto-generated',
+                'h:X-Auto-Response-Suppress': 'OOF, AutoReply'
             };
 
             // Do we have a custom List-Unsubscribe header set?

package/core/server/services/member-welcome-emails/jobs/index.js

@@ -1,6 +1,6 @@
 const path = require('path');
 const jobsService = require('../../jobs');
-const labs = require('../../../../shared/labs');
+const config = require('../../../../shared/config');
 
 let hasScheduled = {
     processOutbox: false
@@ -8,7 +8,7 @@ let hasScheduled = {
 
 module.exports = {
     async scheduleMemberWelcomeEmailJob() {
-        if (!labs.isSet('welcomeEmails')) {
+        if (!config.get('memberWelcomeEmailTestInbox')) {
             return false;
         }
 

package/core/server/services/members/members-api/repositories/MemberRepository.js

@@ -8,6 +8,7 @@ const ObjectId = require('bson-objectid').default;
 const {NotFoundError} = require('@tryghost/errors');
 const validator = require('@tryghost/validator');
 const crypto = require('crypto');
+const config = require('../../../../../shared/config');
 
 const messages = {
     noStripeConnection: 'Cannot {action} without a Stripe Connection',
@@ -337,7 +338,7 @@ module.exports = class MemberRepository {
 
         const memberAddOptions = {...(options || {}), withRelated};
         let member;
-        if (this._labsService.isSet('welcomeEmails') && WELCOME_EMAIL_SOURCES.includes(source)) {
+        if (config.get('memberWelcomeEmailTestInbox') && WELCOME_EMAIL_SOURCES.includes(source)) {
             const runMemberCreation = async (transacting) => {
                 const newMember = await this._Member.add({
                     ...memberData,

package/core/server/services/tinybird/TinybirdService.js

@@ -48,10 +48,7 @@ const TINYBIRD_PIPES = [
     'api_kpis',
     'api_active_visitors',
     'api_post_visitor_counts',
-    'api_top_browsers',
-    'api_top_devices',
     'api_top_locations',
-    'api_top_os',
     'api_top_pages',
     'api_top_sources',
     'api_top_utm_sources',

package/core/server/web/admin/app.js

@@ -23,8 +23,10 @@ module.exports = function setupAdminApp() {
     //        produced below should be split into separate 'Cache-Control' entry.
     //        For reference see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching#validation_2
 
+    const adminAssetsPath = path.join(config.getAdminAssetsPath(), 'assets');
+
     adminApp.use('/assets', serveStatic(
-        path.join(config.get('paths').adminAssets, 'assets'), {
+        adminAssetsPath, {
             // @NOTE: the maxAge config passed below are in milliseconds and the config
             //        is specified in seconds. See https://github.com/expressjs/serve-static/issues/150 for more context
             maxAge: config.get('caching:admin:maxAge') * 1000,

package/core/server/web/admin/controller.js

@@ -29,7 +29,8 @@ module.exports = function adminController(req, res) {
     // CASE: trigger update check unit and let it run in background, don't block the admin rendering
     updateCheck();
 
-    const templatePath = path.resolve(config.get('paths').adminAssets, 'index.html');
+    const adminAssetsPath = config.getAdminAssetsPath();
+    const templatePath = path.resolve(adminAssetsPath, 'index.html');
     const headers = {};
 
     try {

package/core/shared/config/defaults.json

@@ -218,6 +218,7 @@
     "enableTipsAndDonations": true,
     "emailAnalytics": {
         "enabled": true,
+        "batchProcessing": false,
         "metrics": {
             "openThroughput": {
                 "enabled": false,
@@ -302,5 +303,5 @@
         "captureLinkClickBadMemberUuid": false
     },
     "disableJSBackups": false,
-    "memberWelcomeEmailTestInbox" : ""
+    "memberWelcomeEmailTestInbox": ""
 }

package/core/shared/config/helpers.js

@@ -97,6 +97,18 @@ const getContentPath = function getContentPath(type) {
     }
 };
 
+/**
+ * Get the path to admin assets, switching between Ember and React admin based on USE_REACT_SHELL env var
+ * @returns {string}
+ */
+const getAdminAssetsPath = function getAdminAssetsPath() {
+    const useReactShell = process.env.USE_REACT_SHELL === 'true';
+    if (useReactShell) {
+        return path.join(this.get('paths:appRoot'), '../../apps/admin/dist');
+    }
+    return this.get('paths:adminAssets');
+};
+
 /**
  * @typedef ConfigHelpers
  * @property {isPrivacyDisabledFn} isPrivacyDisabled
@@ -105,6 +117,7 @@ const getContentPath = function getContentPath(type) {
 module.exports.bindAll = (nconf) => {
     nconf.isPrivacyDisabled = isPrivacyDisabled.bind(nconf);
     nconf.getContentPath = getContentPath.bind(nconf);
+    nconf.getAdminAssetsPath = getAdminAssetsPath.bind(nconf);
     nconf.getBackendMountPath = getBackendMountPath.bind(nconf);
     nconf.getFrontendMountPath = getFrontendMountPath.bind(nconf);
 };

package/core/shared/url-utils.js

@@ -6,6 +6,10 @@ const urlUtils = new UrlUtils({
     getSubdir: config.getSubdir,
     getSiteUrl: config.getSiteUrl,
     getAdminUrl: config.getAdminUrl,
+    assetBaseUrls: {
+        media: config.get('urls:media'),
+        files: config.get('urls:files')
+    },
     slugs: config.get('slugs').protected,
     redirectCacheMaxAge: config.get('caching:301:maxAge'),
     baseApiPath: BASE_API_PATH
@@ -13,5 +17,3 @@ const urlUtils = new UrlUtils({
 
 module.exports = urlUtils;
 module.exports.BASE_API_PATH = BASE_API_PATH;
-module.exports.STATIC_MEDIA_URL_PREFIX = 'content/media';
-module.exports.STATIC_FILES_URL_PREFIX = 'content/files';