ghost 6.54.0 → 6.55.0

package/core/server/services/automations/scheduler-poll-time.ts

@@ -0,0 +1,38 @@
+const SCHEDULER_POLL_INTERVAL_MS = 15 * 60 * 1000;
+
+/**
+ * An implementation of the [FNV-1a hash][0].
+ *
+ * We need something that generates per-site jitter within a 15-minute
+ * interval. We want a 32-bit number which we can modulo at the end.
+ *
+ * FNV-1a is good for this purpose because:
+ *
+ * - it is simple
+ * - it generates a 32-bit number
+ * - it is [more efficient than CRC32, MD5, and SHA][1], using less CPU and RAM
+ *
+ * This implementation assumes ASCII strings, which we expect callers to always
+ * use. If that assumption is ever violated, we'll compute incorrect jitter,
+ * which is acceptable.
+ *
+ * [0]: https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash
+ * [1]: https://gist.github.com/EvanHahn/20d845c8157691d24977831159487950
+ */
+const fnv1a32 = (asciiStr: string): number => {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < asciiStr.length; i++) {
+        hash ^= asciiStr.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+};
+
+/**
+ * Round the time up to a 15-minute interval with site-specific jitter.
+ */
+export const getSchedulerPollTime = (date: Readonly<Date>, siteIdentifier: string): Date => {
+    const siteOffset = fnv1a32(siteIdentifier) % SCHEDULER_POLL_INTERVAL_MS;
+    const interval = Math.ceil((date.getTime() - siteOffset) / SCHEDULER_POLL_INTERVAL_MS);
+    return new Date(interval * SCHEDULER_POLL_INTERVAL_MS + siteOffset);
+}

package/core/server/services/automations/service.js

@@ -43,6 +43,7 @@ const poll_1 = require("./poll");
 const automationsApi = __importStar(require("./automations-api"));
 const promises_1 = require("node:timers/promises");
 const soonest_timer_1 = require("../../lib/soonest-timer");
+const scheduler_poll_time_1 = require("./scheduler-poll-time");
 // @ts-expect-error This module currently lacks type definitions.
 const jobs_1 = __importDefault(require("../email-analytics/jobs"));
 const urlUtils = require('../../../shared/url-utils').default;
@@ -54,11 +55,13 @@ const memberWelcomeEmailService = require('../member-welcome-emails/service');
 const scheduleAutomationEmailAnalyticsJob = () => (jobs_1.default.scheduleRecurringAutomationsJob(true));
 class AutomationsService {
     #enqueuePollAt;
-    init({ domainEvents, apiUrl, schedulerAdapter, internalKeys }) {
+    init({ domainEvents, apiUrl, schedulerAdapter, internalKeys, siteUuid }) {
         const isInitialized = Boolean(this.#enqueuePollAt);
         if (isInitialized) {
             return;
         }
+        // If we don't get a valid site UUID for some reason, compute jitter with the API URL.
+        const siteIdentifier = typeof siteUuid === 'string' && siteUuid.length ? siteUuid : apiUrl;
         const enqueuePollNow = () => domainEvents.dispatch(StartAutomationsPollEvent.create());
         const soonestTimer = new soonest_timer_1.SoonestTimer(enqueuePollNow);
         /**
@@ -86,11 +89,20 @@ class AutomationsService {
             }
             soonestTimer.scheduleAt(date);
             try {
+                const schedulerPollTime = (0, scheduler_poll_time_1.getSchedulerPollTime)(date, siteIdentifier);
                 const key = await internalKeys.get('ghost-scheduler');
-                const signedAdminToken = getSignedAdminToken({ publishedAt: date.toISOString(), apiUrl, key });
+                const signedAdminToken = getSignedAdminToken({
+                    publishedAt: schedulerPollTime.toISOString(),
+                    apiUrl,
+                    key
+                });
                 const url = new URL(urlUtils.urlJoin(apiUrl, 'automations', 'poll'));
                 url.searchParams.set('token', signedAdminToken);
-                schedulerAdapter.schedule({ time: date.getTime(), url: url.toString(), extra: { httpMethod: 'PUT' } });
+                schedulerAdapter.schedule({
+                    time: schedulerPollTime.getTime(),
+                    url: url.toString(),
+                    extra: { httpMethod: 'PUT' }
+                });
             }
             catch (err) {
                 logging.error({ event: { name: 'automations.enqueue-poll.error' }, err, at: date.toISOString() }, 'Failed to enqueue automations poll');

package/core/server/services/automations/service.ts

@@ -8,6 +8,7 @@ import {poll} from './poll';
 import * as automationsApi from './automations-api';
 import {setImmediate as flushEventLoop} from 'node:timers/promises';
 import {SoonestTimer} from '../../lib/soonest-timer';
+import {getSchedulerPollTime} from './scheduler-poll-time';
 // @ts-expect-error This module currently lacks type definitions.
 import emailAnalyticsJobs from '../email-analytics/jobs';
 
@@ -23,6 +24,7 @@ type AutomationsServiceOptions = {
     domainEvents: Pick<DomainEvents, 'dispatch' | 'subscribe'>;
     internalKeys: InternalKeys;
     schedulerAdapter: Pick<SchedulerAdapter, 'schedule' | 'register'>;
+    siteUuid: unknown;
 };
 
 const scheduleAutomationEmailAnalyticsJob = () => (
@@ -32,12 +34,14 @@ const scheduleAutomationEmailAnalyticsJob = () => (
 export class AutomationsService {
     #enqueuePollAt: undefined | ((date: Readonly<Date>) => Promise<void>);
 
-    init({domainEvents, apiUrl, schedulerAdapter, internalKeys}: AutomationsServiceOptions): void {
+    init({domainEvents, apiUrl, schedulerAdapter, internalKeys, siteUuid}: AutomationsServiceOptions): void {
         const isInitialized = Boolean(this.#enqueuePollAt);
         if (isInitialized) {
             return;
         }
 
+        // If we don't get a valid site UUID for some reason, compute jitter with the API URL.
+        const siteIdentifier = typeof siteUuid === 'string' && siteUuid.length ? siteUuid : apiUrl;
         const enqueuePollNow = () => domainEvents.dispatch(StartAutomationsPollEvent.create());
 
         const soonestTimer = new SoonestTimer(enqueuePollNow);
@@ -69,11 +73,20 @@ export class AutomationsService {
             soonestTimer.scheduleAt(date);
 
             try {
+                const schedulerPollTime = getSchedulerPollTime(date, siteIdentifier);
                 const key = await internalKeys.get('ghost-scheduler');
-                const signedAdminToken = getSignedAdminToken({publishedAt: date.toISOString(), apiUrl, key});
+                const signedAdminToken = getSignedAdminToken({
+                    publishedAt: schedulerPollTime.toISOString(),
+                    apiUrl,
+                    key
+                });
                 const url = new URL(urlUtils.urlJoin(apiUrl, 'automations', 'poll'));
                 url.searchParams.set('token', signedAdminToken);
-                schedulerAdapter.schedule({time: date.getTime(), url: url.toString(), extra: {httpMethod: 'PUT'}});
+                schedulerAdapter.schedule({
+                    time: schedulerPollTime.getTime(),
+                    url: url.toString(),
+                    extra: {httpMethod: 'PUT'}
+                });
             } catch (err) {
                 logging.error({event: {name: 'automations.enqueue-poll.error'}, err, at: date.toISOString()}, 'Failed to enqueue automations poll');
             }

package/core/server/services/comments/comments-service-emails.js

@@ -26,7 +26,10 @@ class CommentsServiceEmails {
      */
     getPostUrl(post, commentId) {
         const postData = toPlain(post);
-        const baseUrl = this.urlService.facade.getUrlForResource({...postData, type: 'posts'}, {absolute: true});
+        // Comments live on pages as well as posts; the URL service routes by
+        // the passed type, so a page typed 'posts' resolves to /404/.
+        const routerType = postData.type === 'page' ? 'pages' : 'posts';
+        const baseUrl = this.urlService.facade.getUrlForResource({...postData, type: routerType}, {absolute: true});
         return `${baseUrl}#ghost-comments-${commentId}`;
     }
 
@@ -84,12 +87,13 @@ class CommentsServiceEmails {
         }
     }
 
-    async notifyParentCommentAuthor(reply, {type = 'parent'} = {}) {
-        let parent;
-        if (type === 'in_reply_to') {
-            parent = await this.models.Comment.findOne({id: reply.get('in_reply_to_id')});
-        } else {
-            parent = await this.models.Comment.findOne({id: reply.get('parent_id')});
+    /**
+     * @returns {Promise<string|undefined>} The id of the member that was notified, or undefined if no email was sent
+     */
+    async notifyParentCommentAuthor(reply, {type = 'parent', parent = null} = {}) {
+        if (!parent) {
+            const parentId = type === 'in_reply_to' ? reply.get('in_reply_to_id') : reply.get('parent_id');
+            parent = await this.models.Comment.findOne({id: parentId});
         }
         const parentMember = parent.related('member');
 
@@ -137,12 +141,14 @@ class CommentsServiceEmails {
             text
         } = await this.commentsServiceEmailRenderer.renderEmailTemplate('new-comment-reply', templateData);
 
-        return this.sendMail({
+        await this.sendMail({
             to: parentMemberEmail,
             subject,
             html,
             text
         });
+
+        return parentMember.id;
     }
 
     /**

package/core/server/services/comments/comments-service.js

@@ -378,11 +378,16 @@ class CommentsService {
     async sendNewCommentNotifications(comment) {
         await this.emails.notifyPostAuthors(comment);
 
-        if (comment.get('parent_id')) {
-            await this.emails.notifyParentCommentAuthor(comment, {type: 'parent'});
-        }
+        const notifiedMemberId = comment.get('parent_id')
+            ? await this.emails.notifyParentCommentAuthor(comment, {type: 'parent'})
+            : null;
+
         if (comment.get('in_reply_to_id')) {
-            await this.emails.notifyParentCommentAuthor(comment, {type: 'in_reply_to'});
+            const inReplyTo = await this.models.Comment.findOne({id: comment.get('in_reply_to_id')});
+
+            if (inReplyTo && (!notifiedMemberId || inReplyTo.get('member_id') !== notifiedMemberId)) {
+                await this.emails.notifyParentCommentAuthor(comment, {type: 'in_reply_to', parent: inReplyTo});
+            }
         }
     }
 

package/core/server/services/email-rendering/partials/email-wrapper.hbs

@@ -84,7 +84,9 @@
                                                     <table role="presentation" border="0" cellpadding="0" cellspacing="0">
                                                         <tr>
                                                             <td>
-                                                                <a href="{{post.url}}" class="{{classes.titleLink}}">{{post.title}}</a>
+                                                                <h1 class="post-title-heading">
+                                                                    <a href="{{post.url}}" class="{{classes.titleLink}}">{{post.title}}</a>
+                                                                </h1>
                                                             </td>
                                                         </tr>
                                                     </table>

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

@@ -6,7 +6,12 @@ const events = require('../../lib/common/events');
 class EmailServiceWrapper {
     getPostUrl(post) {
         const jsonModel = post.toJSON();
-        url.forPost(post.id, jsonModel, {options: {}});
+        // The URL service routes by resource type. Pages and posts share the
+        // Post model, so the page's own type must reach forPost — otherwise it
+        // defaults to 'posts', matches no post collection, and 404s under the
+        // lazy service.
+        const type = jsonModel.type === 'page' ? 'pages' : 'posts';
+        url.forPost(post.id, jsonModel, {options: {}}, type);
         return jsonModel.url;
     }
 

package/core/server/services/email-service/email-templates/partials/styles.hbs

@@ -161,6 +161,14 @@ img.is-dark-background {
     color: {{postTitleColor}};
 }
 
+/* Outlook's Word engine ignores `inherit`, so repeat the `.post-title > table td` values */
+.post-title-heading {
+    margin: 0;
+    font-size: 36px;
+    line-height: 1.1;
+    font-weight: {{titleWeight}};
+}
+
 .post-title a {
     color: {{postTitleColor}} !important;
 }

package/core/server/services/email-service/newsletter-email-event-storage.js

@@ -1,4 +1,5 @@
 const moment = require('moment-timezone');
+const errors = require('@tryghost/errors');
 const logging = require('@tryghost/logging');
 const config = require('../../../shared/config');
 
@@ -177,11 +178,20 @@ class NewsletterEmailEventStorage {
 
     async handleUnsubscribed(event) {
         try {
-            // Unsubscribe member from the specific newsletter
-            const newsletters = await this.findNewslettersToKeep(event);
-            await this.#membersRepository.update({newsletters}, {id: event.memberId});
+            const result = await this.findNewslettersToKeep(event);
 
-            // Remove member from Mailgun's suppression list
+            if (result.status === 'failed') {
+                // Leave Mailgun's suppression in place: these events are fetched
+                // once and never retried, so it is the only remaining protection.
+                return;
+            }
+
+            if (result.status === 'ok') {
+                await this.#membersRepository.update({newsletters: result.newsletters}, {id: event.memberId});
+            }
+
+            // Remove member from Mailgun's suppression list, only once the local
+            // record reflects the unsubscribe or there is no member left to protect
             await this.#emailSuppressionList.removeUnsubscribe(event.email);
         } catch (err) {
             logging.error(err);
@@ -205,22 +215,43 @@ class NewsletterEmailEventStorage {
         }
     }
 
+    /**
+     * @typedef {{status: 'ok', newsletters: {id: string}[]}
+     *     | {status: 'no-member'}
+     *     | {status: 'failed'}} FindNewslettersToKeepResult
+     */
+
+    /**
+     * @param {import('./events/email-unsubscribed-event')} event
+     * @returns {Promise<FindNewslettersToKeepResult>}
+     */
     async findNewslettersToKeep(event) {
         try {
-            const member = await this.#membersRepository.get({email: event.email}, {
+            const member = await this.#membersRepository.get({id: event.memberId}, {
                 withRelated: ['newsletters']
             });
+
+            if (!member) {
+                return {status: 'no-member'};
+            }
+
             const existingNewsletters = member.related('newsletters');
 
             const email = await this.#models.Email.findOne({id: event.emailId});
             const newsletterToRemove = email.get('newsletter_id');
 
-            return existingNewsletters.models.filter(newsletter => newsletter.id !== newsletterToRemove).map((n) => {
-                return {id: n.id};
-            });
+            return {
+                status: 'ok',
+                newsletters: existingNewsletters.models.filter(newsletter => newsletter.id !== newsletterToRemove).map((n) => {
+                    return {id: n.id};
+                })
+            };
         } catch (err) {
-            logging.error(err);
-            return [];
+            logging.error(new errors.InternalServerError({
+                message: `Could not resolve newsletters to keep for unsubscribe event (member ${event.memberId}, email ${event.emailId})`,
+                err
+            }));
+            return {status: 'failed'};
         }
     }
 

package/core/server/services/lib/dynamic-redirect-manager.js

@@ -56,14 +56,23 @@ class DynamicRedirectManager {
 
         this.router.get(fromRegex, (req, res) => {
             const maxAge = permanent ? this.permanentMaxAge : 0;
-            const toURL = parseURL(to);
-            const toURLParams = parseQuerystring(toURL.query);
             const currentURL = parseURL(req.url);
             const currentURLParams = parseQuerystring(currentURL.query);
+
+            const toURL = parseURL(to);
+            toURL.pathname = currentURL.pathname.replace(fromRegex, toURL.pathname);
+
+            // Captures are percent-encoded path segments (Express rejects any it can't decode),
+            // so decode then re-encode for the query — reserved chars stay literal, no double-encoding
+            const captures = currentURL.pathname.match(fromRegex) || [];
+            const substitutedQuery = (toURL.query || '').replace(/\$(\d+)/g, (match, n) => (
+                captures[n] !== undefined ? encodeURIComponent(decodeURIComponent(captures[n])) : match
+            ));
+            const toURLParams = parseQuerystring(substitutedQuery);
+
             const params = Object.assign({}, currentURLParams, toURLParams);
             const search = formatQuerystring(params);
 
-            toURL.pathname = currentURL.pathname.replace(fromRegex, toURL.pathname);
             toURL.search = search !== '' ? `?${search}` : null;
 
             /**

package/core/server/services/link-redirection/link-redirect-repository.js

@@ -1,3 +1,4 @@
+const crypto = require('crypto');
 const {LinkRedirect} = require('./link-redirect');
 const ObjectID = require('bson-objectid').default;
 const debug = require('@tryghost/debug')('LinkRedirectRepository');
@@ -49,7 +50,11 @@ module.exports = class LinkRedirectRepository {
         const model = await this.#LinkRedirect.add({
             // Only store the pathname (no support for variable query strings)
             from: this.stripSubdirectoryFromPath(linkRedirect.from.pathname),
-            to: linkRedirect.to.href
+            to: linkRedirect.to.href,
+            ...(linkRedirect.automationActionRevisionId ? {
+                automation_action_revision_id: linkRedirect.automationActionRevisionId,
+                to_hash: this.#getToHash(linkRedirect.to)
+            } : {})
         }, {});
 
         linkRedirect.link_id = ObjectID.createFromHexString(model.id);
@@ -82,7 +87,8 @@ module.exports = class LinkRedirectRepository {
             id: model.id,
             from: new URL(this.#trimLeadingSlash(model.get('from')), this.#urlUtils.urlFor('home', true)),
             to: new URL(model.get('to')),
-            edited
+            edited,
+            automationActionRevisionId: model.get('automation_action_revision_id')
         });
     }
 
@@ -93,6 +99,7 @@ module.exports = class LinkRedirectRepository {
      * @param {string} serialized.from - path of the URL
      * @param {string} serialized.to - URL to redirect to
      * @param {boolean} serialized.edited - whether the link has been edited
+     * @param {string} [serialized.automationActionRevisionId] - owning automation action revision
      * @returns {InstanceType<LinkRedirect>} LinkRedirect
      */
     #fromSerialized(serialized) {
@@ -100,7 +107,8 @@ module.exports = class LinkRedirectRepository {
             id: serialized.link_id,
             from: new URL(this.#trimLeadingSlash(serialized.from), this.#urlUtils.urlFor('home', true)),
             to: new URL(serialized.to),
-            edited: serialized.edited
+            edited: serialized.edited,
+            automationActionRevisionId: serialized.automationActionRevisionId
         });
     }
 
@@ -114,7 +122,10 @@ module.exports = class LinkRedirectRepository {
             link_id: linkRedirect.link_id.toHexString(),
             from: linkRedirect.from.pathname,
             to: linkRedirect.to.href,
-            edited: linkRedirect.edited
+            edited: linkRedirect.edited,
+            ...(linkRedirect.automationActionRevisionId ? {
+                automationActionRevisionId: linkRedirect.automationActionRevisionId
+            } : {})
         };
     }
 
@@ -180,6 +191,32 @@ module.exports = class LinkRedirectRepository {
         }
     }
 
+    /**
+     * Get an automation LinkRedirect by action revision and destination URL
+     * @param {string} automationActionRevisionId
+     * @param {Readonly<URL>} url
+     * @returns {Promise<InstanceType<LinkRedirect>|undefined>} LinkRedirect
+     */
+    async getByAutomationActionRevisionAndURL(automationActionRevisionId, url) {
+        const linkRedirectModel = await this.#LinkRedirect.findOne({
+            automation_action_revision_id: automationActionRevisionId,
+            to_hash: this.#getToHash(url)
+        }, {});
+
+        if (linkRedirectModel) {
+            return this.fromModel(linkRedirectModel);
+        }
+    }
+
+    /**
+     * The destination column is too long to index, so unique lookups use its SHA-256 digest
+     * @param {Readonly<URL>} url
+     * @returns {Buffer}
+     */
+    #getToHash(url) {
+        return crypto.createHash('sha256').update(url.href).digest();
+    }
+
     /**
      * Convert root relative URLs to subdirectory relative URLs
      * @param {string} path

package/core/server/services/link-redirection/link-redirect.js

@@ -10,6 +10,7 @@ class LinkRedirect {
     from;
     to;
     edited;
+    automationActionRevisionId;
     constructor(data) {
         if (!data.id) {
             this.link_id = new bson_objectid_1.default();
@@ -20,6 +21,7 @@ class LinkRedirect {
         this.from = data.from;
         this.to = data.to;
         this.edited = !!data.edited;
+        this.automationActionRevisionId = data.automationActionRevisionId ?? undefined;
     }
 }
 exports.LinkRedirect = LinkRedirect;

package/core/server/services/link-redirection/link-redirect.ts

@@ -5,8 +5,9 @@ export class LinkRedirect {
     from: URL;
     to: URL;
     edited: boolean;
+    automationActionRevisionId: string | undefined;
 
-    constructor(data: {id?: string; from: URL; to: URL; edited?: boolean}) {
+    constructor(data: {id?: string; from: URL; to: URL; edited?: boolean; automationActionRevisionId?: string | null}) {
         if (!data.id) {
             this.link_id = new ObjectID();
         }
@@ -18,5 +19,6 @@ export class LinkRedirect {
         this.from = data.from;
         this.to = data.to;
         this.edited = !!data.edited;
+        this.automationActionRevisionId = data.automationActionRevisionId ?? undefined;
     }
 }

package/core/server/services/link-redirection/link-redirects-service.js

@@ -6,6 +6,7 @@ const {LinkRedirect} = require('./link-redirect');
 /**
  * @typedef {object} ILinkRedirectRepository
  * @prop {(url: URL) => Promise<LinkRedirect|undefined>} getByURL
+ * @prop {(automationActionRevisionId: string, url: URL) => Promise<LinkRedirect|undefined>} getByAutomationActionRevisionAndURL
  * @prop {({filter: string}) => Promise<LinkRedirect[]>} getAll
  * @prop {({filter: string}) => Promise<String[]>} getFilteredIds
  * @prop {(linkRedirect: LinkRedirect) => Promise<void>} save
@@ -19,6 +20,8 @@ const MEMBER_UUID_PLACEHOLDER = '%%{uuid}%%';
 //   Ghost uses UUID v4; this regex is not that strict
 const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
+const isUniqueConstraintError = err => err?.code === 'ER_DUP_ENTRY' || err?.code?.startsWith?.('SQLITE_CONSTRAINT');
+
 class LinkRedirectsService {
     /** @type ILinkRedirectRepository */
     #linkRedirectRepository;
@@ -71,13 +74,15 @@ class LinkRedirectsService {
     /**
      * @param {URL} from
      * @param {URL} to
+     * @param {string} [automationActionRevisionId]
      *
      * @returns {Promise<LinkRedirect>}
      */
-    async addRedirect(from, to) {
+    async addRedirect(from, to, automationActionRevisionId) {
         const link = new LinkRedirect({
             from,
-            to
+            to,
+            automationActionRevisionId
         });
 
         await this.#linkRedirectRepository.save(link);
@@ -85,6 +90,37 @@ class LinkRedirectsService {
         return link;
     }
 
+    /**
+     * Get the shared redirect for a destination within an automation action revision,
+     * creating it on first use. A concurrent winning insert is returned after a
+     * duplicate-key failure.
+     * @param {string} automationActionRevisionId
+     * @param {Readonly<URL>} to
+     * @returns {Promise<LinkRedirect>}
+     */
+    async getOrAddAutomationRedirect(automationActionRevisionId, to) {
+        const existing = await this.#linkRedirectRepository.getByAutomationActionRevisionAndURL(automationActionRevisionId, to);
+        if (existing) {
+            return existing;
+        }
+
+        const from = await this.getSlugUrl();
+        try {
+            return await this.addRedirect(from, to, automationActionRevisionId);
+        } catch (err) {
+            if (!isUniqueConstraintError(err)) {
+                throw err;
+            }
+
+            const winner = await this.#linkRedirectRepository.getByAutomationActionRevisionAndURL(automationActionRevisionId, to);
+            if (winner) {
+                return winner;
+            }
+
+            throw err;
+        }
+    }
+
     /**
      * Returns the relative path prefix without subdirectory (e.g., /r/)
      * Used for Express route matching where subdirectory is already stripped

package/core/server/services/link-tracking/click-event.js

@@ -7,6 +7,8 @@ module.exports = class ClickEvent {
     member_uuid;
     /** @type {ObjectID} */
     link_id;
+    /** @type {Date | undefined} */
+    timestamp;
 
     constructor(data) {
         if (!data.id) {
@@ -21,5 +23,6 @@ module.exports = class ClickEvent {
 
         this.member_uuid = data.member_uuid;
         this.link_id = data.link_id;
+        this.timestamp = data.timestamp;
     }
 };

package/core/server/services/link-tracking/index.js

@@ -4,12 +4,37 @@ const errors = require('@tryghost/errors');
 const urlUtils = require('../../../shared/url-utils').default;
 
 class LinkTrackingServiceWrapper {
+    #initPromise;
+    #automationsApi;
+
+    constructor({
+        automationsApi = require('../automations/automations-api')
+    } = {}) {
+        this.#automationsApi = automationsApi;
+    }
+
     async init() {
         if (this.service) {
             // Already done
             return;
         }
 
+        if (!this.#initPromise) {
+            this.#initPromise = this.#initialise();
+        }
+
+        const initPromise = this.#initPromise;
+        try {
+            await initPromise;
+        } catch (error) {
+            if (this.#initPromise === initPromise) {
+                this.#initPromise = undefined;
+            }
+            throw error;
+        }
+    }
+
+    async #initialise() {
         const linkRedirection = require('../link-redirection');
         if (!linkRedirection.service) {
             throw new errors.InternalServerError({message: 'LinkRedirectionService should be initialised before LinkTrackingService'});
@@ -27,24 +52,31 @@ class LinkTrackingServiceWrapper {
             linkRedirectRepository: linkRedirection.linkRedirectRepository
         });
 
-        this.linkClickRepository = new LinkClickRepository({
+        const linkClickRepository = new LinkClickRepository({
             MemberLinkClickEventModel: models.MemberClickEvent,
             Member: models.Member,
             MemberLinkClickEvent: MemberLinkClickEvent,
             DomainEvents
         });
 
-        // Expose the service
-        this.service = new LinkClickTrackingService({
+        const service = new LinkClickTrackingService({
             linkRedirectService: linkRedirection.service,
-            linkClickRepository: this.linkClickRepository,
+            linkClickRepository,
             postLinkRepository,
             DomainEvents,
-            urlUtils
+            urlUtils,
+            automationsApi: this.#automationsApi,
+            runInTransaction: callback => models.Base.transaction(callback)
         });
 
-        await this.service.init();
+        await service.init();
+
+        // Expose the service only after it has finished initialising
+        this.linkClickRepository = linkClickRepository;
+        this.service = service;
     }
 }
 
 module.exports = new LinkTrackingServiceWrapper();
+// Exposed for testing purposes only
+module.exports.LinkTrackingServiceWrapper = LinkTrackingServiceWrapper;