ghost 6.54.1 → 6.56.0

package/core/server/services/automations/database-automations-repository.ts

@@ -4,7 +4,9 @@ import crypto from 'node:crypto';
 import ObjectId from 'bson-objectid';
 import {dequal} from 'dequal';
 import {type Knex} from 'knex';
-import moment from 'moment';
+// @ts-expect-error This module currently lacks type definitions.
+import lexicalLib from '../../lib/lexical';
+import urlUtils from '../../../shared/url-utils';
 import {DEFAULT_EMAIL_DESIGN_SETTING_SLUG, MEMBER_WELCOME_EMAIL_SLUGS} from '../member-welcome-emails/constants';
 import type {
     AutomatedEmailEvents,
@@ -19,11 +21,11 @@ import type {
     EditAutomationData,
     Page
 } from './automations-repository';
+import {toDatabaseDate} from './database-date';
 import {getStaleLockCutoff} from './stale-lock-cutoff';
 import type {ExclusifyUnion, ReadonlyDeep} from 'type-fest';
 
 const HOUR_MS = 60 * 60 * 1000;
-const DATABASE_DATE_FORMAT = 'YYYY-MM-DD HH:mm:ss';
 const DEFAULT_WELCOME_EMAIL_AUTOMATIONS = [{
     name: 'Free member welcome flow',
     slug: MEMBER_WELCOME_EMAIL_SLUGS.free
@@ -50,9 +52,6 @@ interface AutomationRow {
     updated_at: string;
 }
 
-function toDatabaseDate(date: Date | string): string {
-    return moment(date).format(DATABASE_DATE_FORMAT);
-}
 
 interface ActionRow {
     id: string;
@@ -70,6 +69,11 @@ type ActionStatsRow = {
     email_opened_count: number | null;
 };
 
+type ActionLinkRow = {
+    url: string;
+    clicked_count: string | number;
+};
+
 type ActionRevisionRow = {
     action_id: string;
     created_at: string;
@@ -166,6 +170,37 @@ export function createDatabaseAutomationsRepository({
             });
         },
 
+        async getAutomationActionLinks(automationId, actionId) {
+            const action = await knex('automation_actions')
+                .select('id')
+                .where({
+                    id: actionId,
+                    automation_id: automationId
+                })
+                .whereNull('deleted_at')
+                .first();
+
+            if (!action) {
+                return null;
+            }
+
+            const rows = await knex('redirects as redirects')
+                .countDistinct({clicked_count: 'members_click_events.member_id'})
+                .select<ActionLinkRow[]>(knex.raw('MIN(??) as ??', ['redirects.to', 'url']))
+                .innerJoin('automation_action_revisions as revisions', 'revisions.id', 'redirects.automation_action_revision_id')
+                .leftJoin('members_click_events', 'members_click_events.redirect_id', 'redirects.id')
+                .where('revisions.action_id', actionId)
+                .whereNotNull('redirects.to_hash')
+                .groupBy('redirects.to_hash')
+                .orderBy('clicked_count', 'desc')
+                .orderBy('url', 'asc');
+
+            return rows.map(row => ({
+                url: urlUtils.transformReadyToAbsolute(row.url),
+                clicked_count: Number(row.clicked_count)
+            }));
+        },
+
         async edit(id: string, data: EditAutomationData): Promise<Automation | null> {
             return await knex.transaction(async (trx) => {
                 const automation = await loadAutomation(trx, id);
@@ -241,6 +276,7 @@ export function createDatabaseAutomationsRepository({
                     member_email: options.memberEmail,
                     member_name: options.memberName,
                     automation_action_revision_id: options.automationActionRevisionId,
+                    automation_run_step_id: options.automationRunStepId,
                     ...(options.mailgunMessageId ? {mailgun_message_id: options.mailgunMessageId} : {}),
                     track_clicks: options.trackClicks,
                     track_opens: options.trackOpens,
@@ -266,6 +302,15 @@ export function createDatabaseAutomationsRepository({
             }
 
             await knex.transaction(async (trx) => {
+                const revisionIds = new Set<string>();
+                for (const {openedAt, automationActionRevisionId} of eventsByAutomatedEmailRecipientId.values()) {
+                    if (openedAt) {
+                        revisionIds.add(automationActionRevisionId);
+                    }
+                }
+
+                const orderedRevisionIds = await lockActionRevisions(trx, revisionIds);
+
                 const notYetOpened = await lockNotYetOpened(trx, eventsByAutomatedEmailRecipientId);
                 const newOpensPerRevision = new Map<string, number>();
 
@@ -292,11 +337,11 @@ export function createDatabaseAutomationsRepository({
                     }
                 }
 
-                // Keep lock acquisition order consistent across concurrent transactions to avoid deadlocks.
-                const revisions = [...newOpensPerRevision.entries()]
-                    .sort(([left], [right]) => left.localeCompare(right));
-
-                for (const [id, opens] of revisions) {
+                for (const id of orderedRevisionIds) {
+                    const opens = newOpensPerRevision.get(id);
+                    if (!opens) {
+                        continue;
+                    }
                     await trx('automation_action_revisions')
                         .where({id})
                         .update({
@@ -304,10 +349,77 @@ export function createDatabaseAutomationsRepository({
                         });
                 }
             });
+        },
+
+        async trackEmailClicked({automationActionRevisionId, automationRunStepId, memberId, clickedAt}, {transacting} = {}) {
+            const trackClick = async (trx: Knex.Transaction) => {
+                await lockActionRevisions(trx, [automationActionRevisionId]);
+
+                const recipient = await trx('automated_email_recipients')
+                    .select('id', 'clicked_at')
+                    .where({
+                        automation_action_revision_id: automationActionRevisionId,
+                        automation_run_step_id: automationRunStepId,
+                        member_id: memberId,
+                        track_clicks: true
+                    })
+                    .forUpdate()
+                    .first();
+
+                if (!recipient || recipient.clicked_at !== null) {
+                    return;
+                }
+
+                const updated = await trx('automated_email_recipients')
+                    .where({id: recipient.id})
+                    .whereNull('clicked_at')
+                    .update({clicked_at: clickedAt});
+
+                if (updated === 0) {
+                    return;
+                }
+
+                await trx('automation_action_revisions')
+                    .where({id: automationActionRevisionId})
+                    .update({
+                        email_clicked_count: trx.raw('COALESCE(email_clicked_count, 0) + 1')
+                    });
+
+            };
+
+            if (transacting) {
+                await trackClick(transacting);
+                return;
+            }
+
+            await knex.transaction(trackClick);
         }
     };
 }
 
+/**
+ * Lock revisions before recipients because inserting a recipient takes a shared
+ * foreign-key lock on its revision. Updating that revision later can deadlock
+ * with another transaction that has already locked the revision and is waiting
+ * for the recipient. Keep multi-revision lock acquisition deterministic.
+ */
+async function lockActionRevisions(
+    trx: Knex.Transaction,
+    revisionIds: Iterable<string>
+): Promise<string[]> {
+    const sortedRevisionIds = [...new Set(revisionIds)]
+        .sort((left, right) => left.localeCompare(right));
+
+    if (sortedRevisionIds.length > 0) {
+        await trx('automation_action_revisions')
+            .select('id')
+            .whereIn('id', sortedRevisionIds)
+            .forUpdate();
+    }
+
+    return sortedRevisionIds;
+}
+
 /**
  * Which of these recipients have yet to open, and so should count towards their
  * revision's open count. Locks them for the transaction, so a worker racing on
@@ -921,7 +1033,7 @@ async function updateAutomation(trx: Knex.Transaction, automation: AutomationRow
 async function replaceAutomationGraph(trx: Knex.Transaction, automationId: string, submittedActions: AutomationAction[], edges: AutomationEdge[]): Promise<void> {
     const existingActions = await loadAutomationActionRows(trx, automationId);
     const existingActionById = new Map(existingActions.map(action => [action.id, action]));
-    const actions = await resolveEmailDesignSettingIds(trx, submittedActions);
+    const actions = (await resolveEmailDesignSettingIds(trx, submittedActions)).map(formatActionOnWrite);
     const submittedActionIds = new Set(actions.map(action => action.id));
     const actionIdsWithOwners = await loadActionIdsWithOwners(trx, [...submittedActionIds]);
     const latestRevisionByActionId = new Map((await loadLatestActionRevisions(trx, [...submittedActionIds])).map(revision => [revision.action_id, revision]));
@@ -982,6 +1094,23 @@ async function replaceAutomationGraph(trx: Knex.Transaction, automationId: strin
     await insertActionEdges(trx, edges);
 }
 
+function formatActionOnWrite(action: AutomationAction): AutomationAction {
+    if (action.type !== 'send_email') {
+        return action;
+    }
+
+    return {
+        ...action,
+        data: {
+            ...action.data,
+            email_lexical: urlUtils.lexicalToTransformReady(action.data.email_lexical, {
+                nodes: lexicalLib.nodes,
+                transformMap: lexicalLib.urlTransformMap
+            })
+        }
+    };
+}
+
 async function resolveEmailDesignSettingIds(trx: Knex.Transaction, actions: ReadonlyArray<AutomationAction>): Promise<AutomationAction[]> {
     if (!actions.some(action => action.type === 'send_email' && action.data.email_design_setting_id === DEFAULT_EMAIL_DESIGN_SETTING_REFERENCE)) {
         return [...actions];
@@ -1312,7 +1441,7 @@ function buildActionPayload(row: ActionRow, stats: AutomationEmailStats | null):
             type: 'send_email',
             data: {
                 email_subject: requireValue(row, 'email_subject'),
-                email_lexical: requireValue(row, 'email_lexical'),
+                email_lexical: urlUtils.transformReadyToAbsolute(requireValue(row, 'email_lexical')),
                 email_design_setting_id: requireValue(row, 'email_design_setting_id')
             },
             stats: stats ?? EMPTY_EMAIL_STATS

package/core/server/services/automations/database-date.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDatabaseDate = void 0;
+const moment_1 = __importDefault(require("moment"));
+const DATABASE_DATE_FORMAT = 'YYYY-MM-DD HH:mm:ss';
+const toDatabaseDate = (date) => (0, moment_1.default)(date).format(DATABASE_DATE_FORMAT);
+exports.toDatabaseDate = toDatabaseDate;

package/core/server/services/automations/database-date.ts

@@ -0,0 +1,5 @@
+import moment from 'moment';
+
+const DATABASE_DATE_FORMAT = 'YYYY-MM-DD HH:mm:ss';
+
+export const toDatabaseDate = (date: Date | string): string => moment(date).format(DATABASE_DATE_FORMAT);

package/core/server/services/automations/get-scheduler-idempotency-key.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchedulerIdempotencyKey = getSchedulerIdempotencyKey;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+function getSchedulerIdempotencyKey(date, url) {
+    const hash = node_crypto_1.default.createHash('sha256');
+    hash.update(date.toISOString());
+    hash.update(url.href);
+    return `ghost-automations-${hash.digest('hex')}`;
+}

package/core/server/services/automations/get-scheduler-idempotency-key.ts

@@ -0,0 +1,8 @@
+import crypto from 'node:crypto';
+
+export function getSchedulerIdempotencyKey(date: Readonly<Date>, url: Readonly<URL>): string {
+    const hash = crypto.createHash('sha256');
+    hash.update(date.toISOString());
+    hash.update(url.href);
+    return `ghost-automations-${hash.digest('hex')}`;
+}

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

@@ -12,6 +12,7 @@ const constants_2 = require("./constants");
 // @ts-expect-error Models currently lack type definitions.
 const models_1 = require("../../models");
 const settingsCache = require('../../../shared/settings-cache');
+const labs = require('../../../shared/labs');
 const slugToMemberStatus = new Map(Object.entries(constants_1.MEMBER_WELCOME_EMAIL_SLUGS).map(([status, slug]) => [slug, status]));
 const hasUpdatesAndAnnouncementsEnabled = (member) => {
     const preference = member.get('enable_updates_and_announcements');
@@ -112,7 +113,7 @@ const processStep = async ({ automationsApi, memberWelcomeEmailService, schedule
                     break;
                 }
                 memberWelcomeEmailService.init();
-                const trackClicks = Boolean(settingsCache.get('email_track_clicks'));
+                const trackClicks = labs.isSet('automationAnalytics') && Boolean(settingsCache.get('email_track_clicks'));
                 const trackOpens = Boolean(settingsCache.get('email_track_opens'));
                 const sendResult = await memberWelcomeEmailService.api.sendAutomationEmail({
                     email: {
@@ -126,7 +127,10 @@ const processStep = async ({ automationsApi, memberWelcomeEmailService, schedule
                         uuid: member.get('uuid')
                     },
                     memberStatus,
-                    trackOpens
+                    trackOpens,
+                    trackClicks,
+                    automationActionRevisionId: step.automation_action_revision_id,
+                    automationRunStepId: step.id
                 });
                 const mailgunMessageId = (0, mailgun_message_id_1.getMailgunMessageId)(sendResult);
                 // Only Mailgun sends can produce open events for automation emails
@@ -134,6 +138,7 @@ const processStep = async ({ automationsApi, memberWelcomeEmailService, schedule
                 try {
                     await automationsApi.recordEmailSent({
                         automationActionRevisionId: step.automation_action_revision_id,
+                        automationRunStepId: step.id,
                         ...(mailgunMessageId ? { mailgunMessageId } : {}),
                         memberEmail: member.get('email'),
                         memberId: step.member_id,

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

@@ -8,6 +8,7 @@ import {MAX_ATTEMPTS, MAX_STEPS_PER_BATCH, RETRY_DELAY_MS} from './constants';
 import {Member} from '../../models';
 
 const settingsCache = require('../../../shared/settings-cache');
+const labs = require('../../../shared/labs');
 
 type MemberWelcomeEmailService = {
     init: () => unknown;
@@ -25,6 +26,9 @@ type MemberWelcomeEmailService = {
             };
             memberStatus: 'free' | 'paid';
             trackOpens: boolean;
+            trackClicks: boolean;
+            automationActionRevisionId: string;
+            automationRunStepId: string;
         }) => Promise<unknown>;
     };
 };
@@ -183,7 +187,7 @@ const processStep = async ({
                 break;
             }
             memberWelcomeEmailService.init();
-            const trackClicks = Boolean(settingsCache.get('email_track_clicks'));
+            const trackClicks = labs.isSet('automationAnalytics') && Boolean(settingsCache.get('email_track_clicks'));
             const trackOpens = Boolean(settingsCache.get('email_track_opens'));
             const sendResult = await memberWelcomeEmailService.api.sendAutomationEmail({
                 email: {
@@ -197,7 +201,10 @@ const processStep = async ({
                     uuid: member.get('uuid')
                 },
                 memberStatus,
-                trackOpens
+                trackOpens,
+                trackClicks,
+                automationActionRevisionId: step.automation_action_revision_id,
+                automationRunStepId: step.id
             });
             const mailgunMessageId = getMailgunMessageId(sendResult);
             // Only Mailgun sends can produce open events for automation emails
@@ -205,6 +212,7 @@ const processStep = async ({
             try {
                 await automationsApi.recordEmailSent({
                     automationActionRevisionId: step.automation_action_revision_id,
+                    automationRunStepId: step.id,
                     ...(mailgunMessageId ? {mailgunMessageId} : {}),
                     memberEmail: member.get('email'),
                     memberId: step.member_id,

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchedulerPollTime = void 0;
+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) => {
+    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.
+ */
+const getSchedulerPollTime = (date, siteIdentifier) => {
+    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);
+};
+exports.getSchedulerPollTime = getSchedulerPollTime;

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

@@ -41,8 +41,10 @@ const strict_1 = __importDefault(require("node:assert/strict"));
 const one_at_a_time_1 = require("../../../shared/one-at-a-time");
 const poll_1 = require("./poll");
 const automationsApi = __importStar(require("./automations-api"));
+const get_scheduler_idempotency_key_1 = require("./get-scheduler-idempotency-key");
 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 +56,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 +90,23 @@ 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',
+                        idempotencyKey: (0, get_scheduler_idempotency_key_1.getSchedulerIdempotencyKey)(date, url)
+                    }
+                });
             }
             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

@@ -6,8 +6,10 @@ import type DomainEvents from '@tryghost/domain-events';
 import {oneAtATime} from '../../../shared/one-at-a-time';
 import {poll} from './poll';
 import * as automationsApi from './automations-api';
+import {getSchedulerIdempotencyKey} from './get-scheduler-idempotency-key';
 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 +25,7 @@ type AutomationsServiceOptions = {
     domainEvents: Pick<DomainEvents, 'dispatch' | 'subscribe'>;
     internalKeys: InternalKeys;
     schedulerAdapter: Pick<SchedulerAdapter, 'schedule' | 'register'>;
+    siteUuid: unknown;
 };
 
 const scheduleAutomationEmailAnalyticsJob = () => (
@@ -32,12 +35,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 +74,23 @@ 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',
+                        idempotencyKey: getSchedulerIdempotencyKey(date, url)
+                    }
+                });
             } 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

@@ -87,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');
 
@@ -140,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;
 }