ghost 6.56.0 → 6.57.1

package/core/server/services/email-analytics/lib/queries.ts

@@ -0,0 +1,341 @@
+import _ from 'lodash';
+import debugFactory from '@tryghost/debug';
+// @ts-expect-error This module lacks type definitions.
+import db from '../../../data/db';
+import logging from '@tryghost/logging';
+import ObjectID from 'bson-objectid';
+
+const debug = debugFactory('services:email-analytics');
+
+const MIN_EMAIL_COUNT_FOR_OPEN_RATE = 5;
+
+type EmailAnalyticsJobName = string;
+type EmailAnalyticsEvent = 'delivered' | 'opened' | 'failed';
+type CursorSeed = {
+    tableName: string;
+    eventColumns: Partial<Record<EmailAnalyticsEvent, string>>;
+};
+
+/**
+ * Creates a job in the jobs table if it does not already exist.
+ * @param jobName - The name of the job to create.
+ */
+async function createJobIfNotExists(jobName: EmailAnalyticsJobName): Promise<void> {
+    await db.knex('jobs').insert({
+        id: new ObjectID().toHexString(),
+        name: jobName,
+        started_at: new Date(),
+        created_at: new Date(),
+        status: 'started'
+    }).onConflict('name').ignore();
+}
+
+export const queries = {
+    /**
+     * Retrieves the timestamp of the last seen event for the specified email analytics events.
+     * @param jobName - The name of the job to update.
+     * @param events - The email analytics events to consider.
+     * @param cursorSeed - Recipient table and timestamp columns to read the initial cursor from. Used when the job has no stored timestamp yet.
+     * @returns The timestamp of the last seen event, or null if no events are found.
+     */
+    async getLastEventTimestamp(
+        jobName: EmailAnalyticsJobName,
+        events: EmailAnalyticsEvent[],
+        cursorSeed: CursorSeed
+    ): Promise<Date | null> {
+        const startDate = new Date();
+
+        let timestamps: (Date | string | null)[] = [];
+        const lastJobRunTimestamp = await this.getLastJobRunTimestamp(jobName);
+
+        if (lastJobRunTimestamp) {
+            debug(`Using job data for ${jobName}`);
+            timestamps = [lastJobRunTimestamp];
+        } else {
+            debug(`Job data not found for ${jobName}, using ${cursorSeed.tableName} data`);
+            logging.info(`Job data not found for ${jobName}, using ${cursorSeed.tableName} data`);
+
+            for (const event of events) {
+                const columnName = cursorSeed.eventColumns[event];
+                if (!columnName) {
+                    continue;
+                }
+                const row = await db.knex(cursorSeed.tableName)
+                    .select(db.knex.raw('MAX(??) as maxTimestamp', [columnName]))
+                    .first();
+                timestamps.push(row.maxTimestamp);
+            }
+
+            await createJobIfNotExists(jobName);
+        }
+
+        // Convert string dates to Date objects for SQLite compatibility
+        const normalizedTimestamps = timestamps.map(date => {
+            if (!date) {
+                return null;
+            }
+            return date instanceof Date ? date : new Date(date);
+        });
+
+        const lastSeenEventTimestamp = _.max(normalizedTimestamps) ?? null;
+        debug(`getLastEventTimestamp: finished in ${Date.now() - startDate.getTime()}ms`);
+
+        return lastSeenEventTimestamp;
+    },
+
+    /**
+     * Retrieves the job data for the specified job name.
+     * @param jobName - The name of the job to retrieve data for.
+     * @returns The job data, or null if no job data is found.
+     */
+    async getJobData(jobName: EmailAnalyticsJobName) {
+        return await db.knex('jobs').select('finished_at', 'started_at', 'metadata').where('name', jobName).first();
+    },
+
+    /**
+     * Retrieves the timestamp of the last job run for the specified job name.
+     * @param jobName - The name of the job to retrieve the last run timestamp for.
+     * @returns The timestamp of the last job run, or null if no job data is found.
+     */
+    async getLastJobRunTimestamp(jobName: EmailAnalyticsJobName): Promise<Date | null> {
+        const jobData = await this.getJobData(jobName);
+        return jobData ? jobData.finished_at || jobData.started_at : null;
+    },
+
+    /**
+     * Sets the timestamp of the last seen event for the specified email analytics events.
+     * @param jobName - The name of the job to update.
+     * @param field - The field to update.
+     * @param date - The timestamp of the last seen event.
+     * @description
+     * Updates the `finished_at` or `started_at` column of the specified job in the `jobs` table with the provided timestamp.
+     * This is used to keep track of the last time the job was run to avoid expensive queries following reboot.
+     */
+    async setJobTimestamp(jobName: EmailAnalyticsJobName, field: 'finished' | 'started', date: Date): Promise<void> {
+        // Convert string dates to Date objects for SQLite compatibility
+        try {
+            debug(`Setting ${field} timestamp for job ${jobName} to ${date}`);
+            const updateField = field === 'finished' ? 'finished_at' : 'started_at';
+            const status = field === 'finished' ? 'finished' : 'started';
+            const result = await db.knex('jobs').update({[updateField]: date, updated_at: new Date(), status: status}).where('name', jobName);
+            if (result === 0) {
+                await db.knex('jobs').insert({
+                    id: new ObjectID().toHexString(),
+                    name: jobName,
+                    [updateField]: date.toISOString(), // force to iso string for sqlite
+                    updated_at: date.toISOString(), // force to iso string for sqlite
+                    status: status
+                });
+            }
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            debug(`Error setting ${field} timestamp for job ${jobName}: ${message}`);
+        }
+    },
+
+    /**
+     * Retrieves and parses the metadata JSON for the specified job.
+     * @param jobName - The name of the job.
+     * @returns The parsed metadata object, or null.
+     */
+    async getJobMetadata(jobName: EmailAnalyticsJobName): Promise<object | null> {
+        try {
+            const row = await db.knex('jobs').select('metadata').where('name', jobName).first();
+            if (row && row.metadata) {
+                return JSON.parse(row.metadata);
+            }
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            logging.error(`Error reading metadata for job ${jobName}: ${message}`);
+        }
+        return null;
+    },
+
+    /**
+     * Writes metadata JSON for the specified job.
+     * @param jobName - The name of the job.
+     * @param metadata - The metadata to store, or null to clear.
+     */
+    async setJobMetadata(jobName: EmailAnalyticsJobName, metadata: object | null): Promise<void> {
+        try {
+            const value = metadata ? JSON.stringify(metadata) : null;
+            await db.knex.transaction(async (trx: typeof db.knex) => {
+                const result = await trx('jobs').update({metadata: value, updated_at: new Date()}).where('name', jobName);
+                if (result === 0 && metadata) {
+                    await trx('jobs').insert({
+                        id: new ObjectID().toHexString(),
+                        name: jobName,
+                        metadata: value,
+                        created_at: new Date(),
+                        status: 'queued'
+                    });
+                }
+            });
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            logging.error(`Error setting metadata for job ${jobName}: ${message}`);
+        }
+    },
+
+    /**
+     * Sets the status of the specified email analytics job.
+     * @param jobName - The name of the job to update.
+     * @param status - The new status of the job.
+     * @description
+     * Updates the `status` column of the specified job in the `jobs` table with the provided status.
+     * This is used to keep track of the current state of the job.
+     */
+    async setJobStatus(jobName: EmailAnalyticsJobName, status: 'started' | 'finished' | 'failed'): Promise<void> {
+        debug(`Setting status for job ${jobName} to ${status}`);
+        try {
+            const result = await db.knex('jobs')
+                .update({
+                    status: status,
+                    updated_at: new Date()
+                })
+                .where('name', jobName);
+
+            if (result === 0) {
+                await db.knex('jobs').insert({
+                    id: new ObjectID().toHexString(),
+                    name: jobName,
+                    status: status,
+                    created_at: new Date(),
+                    updated_at: new Date()
+                });
+            }
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            debug(`Error setting status for job ${jobName}: ${message}`);
+            throw err;
+        }
+    },
+
+    async aggregateEmailStats(emailId: string, updateOpenedCount: boolean): Promise<void> {
+        const [deliveredCount] = await db.knex('email_recipients').count('id as count').whereRaw('email_id = ? AND delivered_at IS NOT NULL', [emailId]);
+        const [failedCount] = await db.knex('email_recipients').count('id as count').whereRaw('email_id = ? AND failed_at IS NOT NULL', [emailId]);
+
+        const updateData: Record<string, string | number> = {
+            delivered_count: deliveredCount.count,
+            failed_count: failedCount.count
+        };
+
+        if (updateOpenedCount) {
+            const [openedCount] = await db.knex('email_recipients').count('id as count').whereRaw('email_id = ? AND opened_at IS NOT NULL', [emailId]);
+            updateData.opened_count = openedCount.count;
+        }
+
+        await db.knex('emails').update(updateData).where('id', emailId);
+    },
+
+    async aggregateMemberStats(memberId: string): Promise<void> {
+        const {trackedEmailCount} = await db.knex('email_recipients')
+            .select(db.knex.raw('COUNT(email_recipients.id) as trackedEmailCount'))
+            .leftJoin('emails', 'email_recipients.email_id', 'emails.id')
+            .where('email_recipients.member_id', memberId)
+            .where('emails.track_opens', true)
+            .first() || {};
+
+        const [emailCount] = await db.knex('email_recipients').count('id as count').whereRaw('member_id = ?', [memberId]);
+        const [emailOpenedCount] = await db.knex('email_recipients').count('id as count').whereRaw('member_id = ? AND opened_at IS NOT NULL', [memberId]);
+
+        const updateQuery: Record<string, string | number> = {
+            email_count: emailCount.count,
+            email_opened_count: emailOpenedCount.count
+        };
+
+        if (trackedEmailCount >= MIN_EMAIL_COUNT_FOR_OPEN_RATE) {
+            updateQuery.email_open_rate = Math.round(emailOpenedCount.count / trackedEmailCount * 100);
+        }
+
+        await db.knex('members')
+            .update(updateQuery)
+            .where('id', memberId);
+    },
+
+    async aggregateMemberStatsBatch(memberIds: string[]): Promise<void> {
+        if (!memberIds || memberIds.length === 0) {
+            return;
+        }
+
+        // Batch query to get stats for all members at once
+        const stats = await db.knex('email_recipients')
+            .leftJoin('emails', 'emails.id', 'email_recipients.email_id')
+            .select(
+                'email_recipients.member_id',
+                db.knex.raw('COUNT(email_recipients.id) as email_count'),
+                db.knex.raw('SUM(CASE WHEN email_recipients.opened_at IS NOT NULL THEN 1 ELSE 0 END) as email_opened_count'),
+                db.knex.raw('SUM(CASE WHEN emails.track_opens = 1 THEN 1 ELSE 0 END) as tracked_count')
+            )
+            .whereIn('email_recipients.member_id', memberIds)
+            .groupBy('email_recipients.member_id');
+
+        // Build update data for each member
+        const memberStatsMap = new Map<string, {email_count: number; email_opened_count: number; email_open_rate: number | null}>();
+        for (const stat of stats) {
+            const emailOpenRate = stat.tracked_count >= MIN_EMAIL_COUNT_FOR_OPEN_RATE
+                ? Math.round((stat.email_opened_count / stat.tracked_count) * 100)
+                : null;
+
+            memberStatsMap.set(stat.member_id, {
+                email_count: stat.email_count,
+                email_opened_count: stat.email_opened_count,
+                email_open_rate: emailOpenRate
+            });
+        }
+
+        // Build CASE statements for batch update
+        const emailCountCases: string[] = [];
+        const emailOpenedCountCases: string[] = [];
+        const emailOpenRateCases: string[] = [];
+        const emailCountBindings: (string | number)[] = [];
+        const emailOpenedCountBindings: (string | number)[] = [];
+        const emailOpenRateBindings: (string | number)[] = [];
+
+        for (const memberId of memberIds) {
+            const memberStats = memberStatsMap.get(memberId) || {
+                email_count: 0,
+                email_opened_count: 0,
+                email_open_rate: null
+            };
+
+            emailCountCases.push(`WHEN ? THEN ?`);
+            emailCountBindings.push(memberId, memberStats.email_count);
+
+            emailOpenedCountCases.push(`WHEN ? THEN ?`);
+            emailOpenedCountBindings.push(memberId, memberStats.email_opened_count);
+
+            if (memberStats.email_open_rate !== null) {
+                emailOpenRateCases.push(`WHEN ? THEN ?`);
+                emailOpenRateBindings.push(memberId, memberStats.email_open_rate);
+            } else {
+                emailOpenRateCases.push(`WHEN ? THEN NULL`);
+                emailOpenRateBindings.push(memberId);
+            }
+        }
+
+        // Combine bindings in the order they appear in the SQL statement:
+        // 1. All bindings for email_count CASE statement
+        // 2. All bindings for email_opened_count CASE statement
+        // 3. All bindings for email_open_rate CASE statement
+        // 4. Member IDs for the WHERE IN clause
+        const bindings = [
+            ...emailCountBindings,
+            ...emailOpenedCountBindings,
+            ...emailOpenRateBindings,
+            ...memberIds
+        ];
+
+        // Execute batched update with CASE statements
+        await db.knex.raw(`
+            UPDATE members
+            SET
+                email_count = CASE id ${emailCountCases.join(' ')} END,
+                email_opened_count = CASE id ${emailOpenedCountCases.join(' ')} END,
+                email_open_rate = CASE id ${emailOpenRateCases.join(' ')} END
+            WHERE id IN (${memberIds.map(() => '?').join(',')})
+        `, bindings);
+    }
+};
+
+export type Queries = typeof queries;

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

@@ -31,7 +31,7 @@ class EmailServiceWrapper {
 
         const {Post, Newsletter, Email, EmailBatch, EmailRecipient, Member} = require('../../models');
         const urlService = require('../url');
-        const getRequiredUrlRelations = () => urlService.facade.getRequiredRelations();
+        const getRequiredUrlRelations = () => urlService.getRequiredRelations();
         const MailgunClient = require('../lib/mailgun-client');
         const configService = require('../../../shared/config');
         const settingsCache = require('../../../shared/settings-cache');
@@ -75,6 +75,7 @@ class EmailServiceWrapper {
 
         const mailgunEmailProvider = new MailgunEmailProvider({
             mailgunClient,
+            config: configService,
             errorHandler
         });
 

package/core/server/services/email-service/mailgun-email-provider.js

@@ -2,6 +2,11 @@ const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
 const debug = require('@tryghost/debug')('email-service:mailgun-provider-service');
 
+/**
+ * @typedef {object} Config
+ * @prop {(key: string) => unknown} get
+ */
+
 /**
  * @typedef {object} Recipient
  * @prop {string} email
@@ -29,18 +34,22 @@ const debug = require('@tryghost/debug')('email-service:mailgun-provider-service
 
 class MailgunEmailProvider {
     #mailgunClient;
+    #config;
     #errorHandler;
 
     /**
      * @param {object} dependencies
      * @param {import('../lib/mailgun-client')} dependencies.mailgunClient - mailgun client to send emails
+     * @param {Config} dependencies.config
      * @param {Function} [dependencies.errorHandler] - custom error handler for logging exceptions
      */
     constructor({
         mailgunClient,
+        config,
         errorHandler
     }) {
         this.#mailgunClient = mailgunClient;
+        this.#config = config;
         this.#errorHandler = errorHandler;
     }
 
@@ -108,12 +117,18 @@ class MailgunEmailProvider {
                 plaintext,
                 from,
                 replyTo,
+                tags: ['bulk-email'],
                 domainOverride,
                 id: emailId,
                 track_opens: !!options.openTrackingEnabled,
                 track_clicks: !!options.clickTrackingEnabled
             };
 
+            const mailgunTagFromConfig = this.#config.get('bulkEmail:mailgun:tag');
+            if (typeof mailgunTagFromConfig === 'string' && mailgunTagFromConfig.length > 0) {
+                messageData.tags.push(mailgunTagFromConfig);
+            }
+
             if (options.deliveryTime && options.deliveryTime instanceof Date) {
                 messageData.deliveryTime = options.deliveryTime;
             }

package/core/server/services/indexnow-ping/index.js

@@ -11,7 +11,6 @@ class IndexNowPingServiceWrapper {
         // Wire up all the dependencies
         const settingsCache = require('../../../shared/settings-cache');
         const config = require('../../../shared/config');
-        const labs = require('../../../shared/labs');
         const urlService = require('../url');
         const urlUtils = require('../../../shared/url-utils').default;
         const request = require('@tryghost/request');
@@ -20,7 +19,6 @@ class IndexNowPingServiceWrapper {
         this.service = new indexnow_ping_service_1.IndexNowPingService({
             settingsCache,
             config,
-            labs,
             urlService,
             urlUtils,
             request,

package/core/server/services/indexnow-ping/index.ts

@@ -12,7 +12,6 @@ class IndexNowPingServiceWrapper {
         // Wire up all the dependencies
         const settingsCache = require('../../../shared/settings-cache');
         const config = require('../../../shared/config');
-        const labs = require('../../../shared/labs');
         const urlService = require('../url');
         const urlUtils = require('../../../shared/url-utils').default;
         const request = require('@tryghost/request');
@@ -22,7 +21,6 @@ class IndexNowPingServiceWrapper {
         this.service = new IndexNowPingService({
             settingsCache,
             config,
-            labs,
             urlService,
             urlUtils,
             request,

package/core/server/services/indexnow-ping/indexnow-ping-service.js

@@ -31,17 +31,15 @@ const constants_1 = require("./constants");
 class IndexNowPingService {
     settingsCache;
     config;
-    labs;
     urlService;
     urlUtils;
     request;
     logging;
     events;
     listener;
-    constructor({ settingsCache, config, labs, urlService, urlUtils, request, logging, events }) {
+    constructor({ settingsCache, config, urlService, urlUtils, request, logging, events }) {
         this.settingsCache = settingsCache;
         this.config = config;
-        this.labs = labs;
         this.urlService = urlService;
         this.urlUtils = urlUtils;
         this.request = request;
@@ -68,6 +66,10 @@ class IndexNowPingService {
      * Ping IndexNow with a URL.
      */
     async ping(post) {
+        // Skip if in development
+        if (this.config.get('env') === 'development') {
+            return;
+        }
         // Skip pages - only ping for posts
         if (post.type === 'page') {
             return;
@@ -80,10 +82,6 @@ class IndexNowPingService {
         if (this.config.isPrivacyDisabled('useIndexNow')) {
             return;
         }
-        // Skip if IndexNow is not enabled in labs
-        if (!this.labs.isSet('indexnow')) {
-            return;
-        }
         // Don't ping for the default posts
         if (post.slug && constants_1.defaultPostSlugs.indexOf(post.slug) > -1) {
             return;
@@ -94,7 +92,7 @@ class IndexNowPingService {
         // publishing.
         let url = null;
         try {
-            url = this.urlService.facade.getUrlForResource({ ...post, type: 'posts' }, { absolute: true });
+            url = this.urlService.getUrlForResource({ ...post, type: 'posts' }, { absolute: true });
             if (!url || url.endsWith('/404/')) {
                 this.logging.warn({
                     event: { name: 'indexnow.unresolved_url' },

package/core/server/services/indexnow-ping/indexnow-ping-service.ts

@@ -36,17 +36,12 @@ type SettingsCache = {
 };
 
 type Config = {
+    get(key: string): unknown;
     isPrivacyDisabled(key: string): boolean;
 };
 
-type Labs = {
-    isSet(flag: string): boolean;
-};
-
 type UrlService = {
-    facade: {
-        getUrlForResource(resource: Record<string, unknown>, options: {absolute: boolean}): string | null;
-    };
+    getUrlForResource(resource: Record<string, unknown>, options: {absolute: boolean}): string | null;
 };
 
 type UrlUtils = {
@@ -86,7 +81,6 @@ type Post = {
 export type IndexNowPingServiceDeps = {
     settingsCache: SettingsCache;
     config: Config;
-    labs: Labs;
     urlService: UrlService;
     urlUtils: UrlUtils;
     request: RequestFn;
@@ -97,7 +91,6 @@ export type IndexNowPingServiceDeps = {
 export class IndexNowPingService {
     settingsCache: SettingsCache;
     config: Config;
-    labs: Labs;
     urlService: UrlService;
     urlUtils: UrlUtils;
     request: RequestFn;
@@ -105,10 +98,9 @@ export class IndexNowPingService {
     events: ModelEvents;
     listener: ModelEventListener;
 
-    constructor({settingsCache, config, labs, urlService, urlUtils, request, logging, events}: IndexNowPingServiceDeps) {
+    constructor({settingsCache, config, urlService, urlUtils, request, logging, events}: IndexNowPingServiceDeps) {
         this.settingsCache = settingsCache;
         this.config = config;
-        this.labs = labs;
         this.urlService = urlService;
         this.urlUtils = urlUtils;
         this.request = request;
@@ -139,6 +131,11 @@ export class IndexNowPingService {
      * Ping IndexNow with a URL.
      */
     async ping(post: Post): Promise<void> {
+        // Skip if in development
+        if (this.config.get('env') === 'development') {
+            return;
+        }
+
         // Skip pages - only ping for posts
         if (post.type === 'page') {
             return;
@@ -154,11 +151,6 @@ export class IndexNowPingService {
             return;
         }
 
-        // Skip if IndexNow is not enabled in labs
-        if (!this.labs.isSet('indexnow')) {
-            return;
-        }
-
         // Don't ping for the default posts
         if (post.slug && defaultPostSlugs.indexOf(post.slug) > -1) {
             return;
@@ -170,7 +162,7 @@ export class IndexNowPingService {
         // publishing.
         let url: string | null = null;
         try {
-            url = this.urlService.facade.getUrlForResource({...post, type: 'posts'}, {absolute: true});
+            url = this.urlService.getUrlForResource({...post, type: 'posts'}, {absolute: true});
 
             if (!url || url.endsWith('/404/')) {
                 this.logging.warn({

package/core/server/services/lib/mailgun-client.js

@@ -85,9 +85,9 @@ module.exports = class MailgunClient {
                 messageData['v:email-id'] = message.id;
             }
 
-            const tags = ['bulk-email', 'ghost-email'];
-            if (bulkEmailConfig?.mailgun?.tag) {
-                tags.push(bulkEmailConfig.mailgun.tag);
+            const tags = ['ghost-email'];
+            if (Array.isArray(message.tags)) {
+                tags.push(...message.tags);
             }
             messageData['o:tag'] = tags;
 

package/core/server/services/media-inliner/external-media-inliner.js

@@ -5,7 +5,6 @@ const errors = require('@tryghost/errors');
 const logging = require('@tryghost/logging');
 const string = require('@tryghost/string');
 const path = require('path');
-const convert = require('heic-convert');
 
 let fileTypeFromBuffer;
 
@@ -102,20 +101,25 @@ class ExternalMediaInliner {
         }
 
         // If the file is heic or heif, attempt to convert it to jpeg
-        try {
-            if (extension === 'heic' || extension === 'heif') {
+        if (extension === 'heic' || extension === 'heif') {
+            // Lazy: pulls in libheif-js, a WASM codec costing ~50ms to load at boot.
+            // Deliberately outside the try — a missing codec is not a conversion error,
+            // and swallowing it would store an unconvertible .heic in its place.
+            const convert = require('heic-convert');
+
+            try {
                 body = await convert({
                     buffer: body,
                     format: 'JPEG'
                 });
 
                 extension = 'jpg';
+            } catch (error) {
+                logging.error(`Error converting file to JPEG: ${requestURL}`);
+                logging.error(new errors.DataImportError({
+                    err: error
+                }));
             }
-        } catch (error) {
-            logging.error(`Error converting file to JPEG: ${requestURL}`);
-            logging.error(new errors.DataImportError({
-                err: error
-            }));
         }
 
         const removeExtRegExp = new RegExp(`.${extension}`, '');

package/core/server/services/member-attribution/url-translator.js

@@ -1,9 +1,7 @@
 /**
  * @typedef {Object} UrlService
- * @prop {{
- *   getUrlForResource: (resource: Object, options: Object) => string,
- *   resolveUrl: (path: string) => Promise<Object | null>
- * }} facade
+ * @prop {(resource: Object, options: Object) => string} getUrlForResource
+ * @prop {(path: string) => Promise<Object | null>} resolveUrl
  */
 
 const {toPlain} = require('../../lib/common/to-plain');
@@ -106,7 +104,7 @@ class UrlTranslator {
         // surface as an error.
         let resource;
         try {
-            resource = await this.urlService.facade.resolveUrl(path);
+            resource = await this.urlService.resolveUrl(path);
         } catch (err) {
             return;
         }
@@ -155,10 +153,10 @@ class UrlTranslator {
         }
         // Lazy URL service evaluates permalink templates against resource fields
         // (slug, published_at, primary_tag, ...). Caller already loaded the model,
-        // so spread its plain data so those fields reach the facade.
+        // so spread its plain data so those fields reach the URL service.
         const data = toPlain(model);
         const resource = {...data, id, type: TYPE_TO_RESOURCE[type]};
-        return this.urlService.facade.getUrlForResource(resource, {absolute});
+        return this.urlService.getUrlForResource(resource, {absolute});
     }
 
     async getResourceById(id, type) {