ghost 6.55.0 → 6.56.0

package/core/frontend/services/routing/permalink-adapter.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toExpressNotation = toExpressNotation;
+exports.toDomainNotation = toDomainNotation;
+/**
+ * Convert a domain-model permalink into Express / URL-service notation.
+ *
+ * @example toExpressNotation('/{slug}/')               // => '/:slug/'
+ * @example toExpressNotation('/{primary_tag}/{slug}/') // => '/:primary_tag/:slug/'
+ * @example toExpressNotation('/:slug/')                // => '/:slug/' (idempotent)
+ */
+function toExpressNotation(permalink) {
+    return permalink.replace(/{(\w+)}/g, ':$1');
+}
+/**
+ * Convert an Express / URL-service permalink back into domain-model notation.
+ * Will be used on the download path when serialising the canonical shape back
+ * to YAML — no production caller yet.
+ *
+ * @example toDomainNotation('/:slug/')               // => '/{slug}/'
+ * @example toDomainNotation('/:primary_tag/:slug/')  // => '/{primary_tag}/{slug}/'
+ * @example toDomainNotation('/{slug}/')              // => '/{slug}/' (idempotent)
+ */
+function toDomainNotation(permalink) {
+    return permalink.replace(/:(\w+)/g, '{$1}');
+}

package/core/frontend/services/routing/permalink-adapter.ts

@@ -0,0 +1,23 @@
+/**
+ * Convert a domain-model permalink into Express / URL-service notation.
+ *
+ * @example toExpressNotation('/{slug}/')               // => '/:slug/'
+ * @example toExpressNotation('/{primary_tag}/{slug}/') // => '/:primary_tag/:slug/'
+ * @example toExpressNotation('/:slug/')                // => '/:slug/' (idempotent)
+ */
+export function toExpressNotation(permalink: string): string {
+    return permalink.replace(/{(\w+)}/g, ':$1');
+}
+
+/**
+ * Convert an Express / URL-service permalink back into domain-model notation.
+ * Will be used on the download path when serialising the canonical shape back
+ * to YAML — no production caller yet.
+ *
+ * @example toDomainNotation('/:slug/')               // => '/{slug}/'
+ * @example toDomainNotation('/:primary_tag/:slug/')  // => '/{primary_tag}/{slug}/'
+ * @example toDomainNotation('/{slug}/')              // => '/{slug}/' (idempotent)
+ */
+export function toDomainNotation(permalink: string): string {
+    return permalink.replace(/:(\w+)/g, '{$1}');
+}

package/core/frontend/services/routing/registry.js

@@ -1,58 +1,82 @@
 const _ = require('lodash');
-let routes = [];
-let routers = {};
 
 /**
- * @description The router registry is helpful for debugging purposes and let's you search existing routes and routers.
+ * Every registered router is a Ghost router — `ParentRouter` itself (the site
+ * and apps routers) or one of its subclasses (Collection, StaticRoutes,
+ * Taxonomy, StaticPages, Preview, Email, Unsubscribe). They wrap an Express
+ * router, reachable via `.router()`, but are not one themselves: the registry's
+ * own lookups read Ghost-side members (`.name`, `.routerName`, `.reset()`,
+ * `.getRssUrl()`) that an Express router does not have.
+ *
+ * Type-only import — no runtime require, so this does not close a cycle with
+ * `parent-router.js`, which requires this module.
+ *
+ * @typedef {import('./parent-router')} ParentRouter
  */
-module.exports = {
+
+/**
+ * @description The router registry is helpful for debugging purposes and lets you search existing routes and routers.
+ *
+ * Exported as a single shared instance so that every consumer
+ * (`routing/index.js`, `parent-router.js`) operates on the same registry, the
+ * same way the previous module-level state did — just held on an instance
+ * rather than in module-scoped `let` variables.
+ */
+class Registry {
+    constructor() {
+        /** @type {Array<{route: string, from: string}>} */
+        this.routes = [];
+        /** @type {Object<string, ParentRouter>} */
+        this.routers = {};
+    }
+
     /**
-     * @description Get's called if you register a url pattern in express.
+     * @description Gets called if you register a url pattern in express.
      * @param {string} routerName
      * @param {string} route
      */
     setRoute(routerName, route) {
-        routes.push({route: route, from: routerName});
-    },
+        this.routes.push({route: route, from: routerName});
+    }
 
     /**
-     * @description Get's called if you register a router in express.
+     * @description Gets called if you register a router in express.
      * @param {string} name
-     * @param {import('express').Router} router
+     * @param {ParentRouter} router
      */
     setRouter(name, router) {
-        routers[name] = router;
-    },
+        this.routers[name] = router;
+    }
 
     /**
      * @description Get all registered routes.
-     * @returns {Array}
+     * @returns {Array<{route: string, from: string}>}
      */
     getAllRoutes() {
-        return _.cloneDeep(routes);
-    },
+        return _.cloneDeep(this.routes);
+    }
 
     /**
      * @description Get router by name.
      * @param {string} name
-     * @returns {import('express').Router}
+     * @returns {ParentRouter|undefined}
      */
     getRouter(name) {
-        return routers[name];
-    },
+        return this.routers[name];
+    }
 
     /**
-     * Gets a router by it's internal router name
+     * Gets a router by its internal router name
      * @param {string} name internal router name
-     * @returns {import('express').Router}
+     * @returns {ParentRouter|undefined}
      */
     getRouterByName(name) {
-        for (let routerKey in routers) {
-            if (routers[routerKey].name === name) {
-                return routers[routerKey];
+        for (let routerKey in this.routers) {
+            if (this.routers[routerKey].name === name) {
+                return this.routers[routerKey];
             }
         }
-    },
+    }
 
     /**
      *
@@ -77,7 +101,7 @@ module.exports = {
     getRssUrl(options) {
         let rssUrl = null;
 
-        const collectionIndexRouter = _.find(routers, {name: 'CollectionRouter', routerName: 'index'});
+        const collectionIndexRouter = _.find(this.routers, {name: 'CollectionRouter', routerName: 'index'});
 
         if (collectionIndexRouter) {
             rssUrl = collectionIndexRouter.getRssUrl(options);
@@ -88,7 +112,7 @@ module.exports = {
             }
         }
 
-        const collectionRouters = _.filter(routers, {name: 'CollectionRouter'});
+        const collectionRouters = _.filter(this.routers, {name: 'CollectionRouter'});
 
         if (collectionRouters && collectionRouters.length === 1) {
             rssUrl = collectionRouters[0].getRssUrl(options);
@@ -108,32 +132,34 @@ module.exports = {
         }
 
         return rssUrl;
-    },
+    }
 
     /**
      * @description Reset all routes.
      */
     resetAllRoutes() {
-        routes = [];
-    },
+        this.routes = [];
+    }
 
     /**
      * @description Reset all routers.
      */
     resetAllRouters() {
-        _.each(routers, (value) => {
+        _.each(this.routers, (value) => {
             if (value && typeof value.reset === 'function') {
                 value.reset();
             }
         });
 
-        routers = {};
-    },
+        this.routers = {};
+    }
 
     /**
      * @description Clear all routers (for testing).
      */
     clearAllRouters() {
-        routers = {};
+        this.routers = {};
     }
-};
+}
+
+module.exports = new Registry();

package/core/frontend/services/routing/router-manager.js

@@ -90,10 +90,10 @@ class RouterManager {
      * 5. Static Pages: Weaker than collections, because we first try to find a post slug and fallback to lookup a static page.
      * 6. Internal Apps: Weakest
      *
-     * @param {object} routerSettings
+     * @param {RouteSettings} routeSettings
      */
-    start(routerSettings) {
-        debug('routing start', routerSettings);
+    start(routeSettings) {
+        debug('routing start', routeSettings);
         const RESOURCE_CONFIG = require(`./config`);
 
         const unsubscribeRouter = new UnsubscribeRouter();
@@ -110,14 +110,14 @@ class RouterManager {
         this.siteRouter.mountRouter(previewRouter.router());
         this.registry.setRouter('previewRouter', previewRouter);
 
-        for (const route of routerSettings.routes) {
+        for (const route of routeSettings.routes) {
             const staticRoutesRouter = new StaticRoutesRouter(route.path, route, this.routerCreated.bind(this));
             this.siteRouter.mountRouter(staticRoutesRouter.router());
 
             this.registry.setRouter(staticRoutesRouter.identifier, staticRoutesRouter);
         }
 
-        for (const collection of routerSettings.collections) {
+        for (const collection of routeSettings.collections) {
             const collectionRouter = new CollectionRouter(collection.path, collection, RESOURCE_CONFIG, this.routerCreated.bind(this));
             this.siteRouter.mountRouter(collectionRouter.router());
             this.registry.setRouter(collectionRouter.identifier, collectionRouter);
@@ -128,8 +128,8 @@ class RouterManager {
 
         this.registry.setRouter('staticPagesRouter', staticPagesRouter);
 
-        for (const taxonomy of routerSettings.taxonomies) {
-            const taxonomyRouter = new TaxonomyRouter(taxonomy.key, taxonomy.permalink, RESOURCE_CONFIG, this.routerCreated.bind(this));
+        for (const [key, permalink] of Object.entries(routeSettings.taxonomies)) {
+            const taxonomyRouter = new TaxonomyRouter(key, permalink, RESOURCE_CONFIG, this.routerCreated.bind(this));
             this.siteRouter.mountRouter(taxonomyRouter.router());
 
             this.registry.setRouter(taxonomyRouter.identifier, taxonomyRouter);
@@ -180,16 +180,12 @@ module.exports = RouterManager;
 
 /**
  * @typedef {Object} RouterConfig
- * @property {RouteSettings} [routeSettings] - JSON config representing routes
+ * @property {RouteSettings} [routeSettings] - parsed route settings domain model
  * @property {URLServiceFacade} urlService - resource-based URL service facade
  */
 
 /**
- * The shape RouterManager consumes — produced by the activation bridge. This is
- * a temporary reference into server code; when the bridge is removed (HKG-1898)
- * it becomes the domain `RouteSettings` from @tryghost/adapter-base-route-settings.
- *
- * @typedef {import('../../../server/services/route-settings/activation-bridge').RouterSettings} RouteSettings
+ * @typedef {import('@tryghost/adapter-base-route-settings').RouteSettings} RouteSettings
  */
 
 /**

package/core/frontend/services/routing/static-routes-router.js

@@ -15,7 +15,7 @@ class StaticRoutesRouter extends ParentRouter {
 
         this.route = {value: mainRoute};
         this.templates = object.templates || [];
-        this.data = object.data || {query: {}, router: {}};
+        this.data = object.data || {};
         this.routerName = mainRoute === '/' ? 'index' : mainRoute.replace(/\//g, '');
         this.routerCreated = routerCreated;
 
@@ -80,7 +80,7 @@ class StaticRoutesRouter extends ParentRouter {
             filter: this.filter,
             limit: this.limit,
             order: this.order,
-            data: this.data.query,
+            data: this.data,
             templates: this.templates
         };
 
@@ -117,7 +117,7 @@ class StaticRoutesRouter extends ParentRouter {
                     message: `Missing template ${res.routerOptions.templates.map(x => `${x}.hbs`).join(', ')} for route "${req.originalUrl}".`
                 });
             },
-            data: this.data.query,
+            data: this.data,
             context: [this.routerName],
             contentType: this.contentType
         };
@@ -131,7 +131,7 @@ class StaticRoutesRouter extends ParentRouter {
      * @returns {boolean}
      */
     isChannel(object) {
-        // buildRouterSettings always sets `type` ('channel' | 'template') on
+        // parseRouteSettings always sets `type` ('channel' | 'template') on
         // every route, so a channel is simply `type === 'channel'`.
         return object?.type === 'channel';
     }

package/core/frontend/services/routing/taxonomy-router.js

@@ -5,6 +5,7 @@ const RSSRouter = require('./rss-router');
 const urlUtils = require('../../../shared/url-utils').default;
 const controllers = require('./controllers');
 const middleware = require('./middleware');
+const {toExpressNotation} = require('./permalink-adapter');
 
 /**
  * @description Taxonomies are groupings of posts based on a common relation.
@@ -17,8 +18,9 @@ class TaxonomyRouter extends ParentRouter {
         this.taxonomyKey = key;
         this.RESOURCE_CONFIG = RESOURCE_CONFIG;
 
+        // convert domain `{slug}` -> Express/URL-service `:slug` at this boundary
         this.permalinks = {
-            value: permalinks
+            value: toExpressNotation(permalinks)
         };
 
         this.permalinks.getValue = () => {
@@ -74,7 +76,9 @@ class TaxonomyRouter extends ParentRouter {
             type: 'channel',
             name: this.taxonomyKey,
             permalinks: this.permalinks.getValue(),
-            data: {[this.taxonomyKey]: this.RESOURCE_CONFIG.QUERY[this.taxonomyKey]},
+            // Route data in domain form — the API adapter resolves it to a
+            // controller call, and fetch-data fills `%s` in from the request.
+            data: {[this.taxonomyKey]: {type: 'read', resource: this.getResourceType(), slug: '%s'}},
             filter: this.RESOURCE_CONFIG.TAXONOMIES[this.taxonomyKey].filter,
             resourceType: this.getResourceType(),
             context: [this.taxonomyKey],

package/core/server/data/migrations/versions/6.56/2026-08-03-19-27-51-add-automation-run-step-id-to-automated-email-recipients.js

@@ -0,0 +1,8 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('automated_email_recipients', 'automation_run_step_id', {
+    type: 'string',
+    maxlength: 24,
+    nullable: true,
+    references: 'automation_run_steps.id'
+}, {algorithm: 'auto'});

package/core/server/data/migrations/versions/6.56/2026-08-04-14-42-39-restrict-notification-add-permission-to-administrators.js

@@ -0,0 +1,12 @@
+const {combineTransactionalMigrations, removePermissionFromRole} = require('../../utils');
+
+module.exports = combineTransactionalMigrations(
+    removePermissionFromRole({
+        permission: 'Add notifications',
+        role: 'Editor'
+    }),
+    removePermissionFromRole({
+        permission: 'Add notifications',
+        role: 'Super Editor'
+    })
+);

package/core/server/data/schema/fixtures/fixtures.json

@@ -1066,7 +1066,7 @@
                     "gift_link": "manage"
                 },
                 "Super Editor": {
-                    "notification": "all",
+                    "notification": ["browse", "destroy"],
                     "post": "all",
                     "setting": ["browse", "read"],
                     "slug": "all",
@@ -1091,7 +1091,7 @@
                     "gift_link": "manage"
                 },
                 "Editor": {
-                    "notification": "all",
+                    "notification": ["browse", "destroy"],
                     "post": "all",
                     "setting": ["browse", "read"],
                     "slug": "all",

package/core/server/data/schema/schema.js

@@ -1339,6 +1339,7 @@ module.exports = {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         automated_email_id: {type: 'string', maxlength: 24, nullable: true, references: 'welcome_email_automated_emails.id'},
         automation_action_revision_id: {type: 'string', maxlength: 24, nullable: true, references: 'automation_action_revisions.id'},
+        automation_run_step_id: {type: 'string', maxlength: 24, nullable: true, references: 'automation_run_steps.id'},
         member_id: {type: 'string', maxlength: 24, nullable: false, index: true},
         member_uuid: {type: 'string', maxlength: 36, nullable: false},
         member_email: {type: 'string', maxlength: 191, nullable: false},

package/core/server/models/post.js

@@ -1346,7 +1346,16 @@ Post = ghostBookshelf.Model.extend({
     destroy: function destroy(unfilteredOptions) {
         let options = this.filterOptions(unfilteredOptions, 'destroy', {extraAllowedProperties: ['id']});
 
-        const destroyPost = () => {
+        const destroyPost = async () => {
+            // The `comments.in_reply_to_id` references form chains between a post's
+            // comments, which MySQL cannot resolve while cascade-deleting them
+            // alongside `comments.parent_id`. Clear the references first so the
+            // `comments.post_id` cascade delete can do its job
+            await ghostBookshelf.knex('comments')
+                .where('post_id', options.id)
+                .update('in_reply_to_id', null)
+                .transacting(options.transacting);
+
             return ghostBookshelf.Model.destroy.call(this, options);
         };
 

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

@@ -90,6 +90,7 @@ export type AutomatedEmailEvents = {
 
 export type RecordEmailSentOptions = Readonly<{
     automationActionRevisionId: string;
+    automationRunStepId: string;
     mailgunMessageId?: string;
     memberEmail: string;
     memberId: string;
@@ -203,11 +204,12 @@ export interface AutomationsRepository {
         eventsByAutomatedEmailRecipientId: ReadonlyDeep<Map<string, AutomatedEmailEvents>>
     ): Promise<void>;
     /**
-     * Track the first click for an automated email recipient.
+     * Record the first click timestamp for the automated email recipient identified by a run step.
      *
      */
     trackEmailClicked(options: {
         automationActionRevisionId: string;
+        automationRunStepId: string;
         memberId: string;
         clickedAt: Readonly<Date>;
     }, transactionOptions?: {

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

@@ -135,6 +135,7 @@ function createDatabaseAutomationsRepository({ knex, fakeWaitHoursMultiplier })
                     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,
@@ -157,6 +158,13 @@ function createDatabaseAutomationsRepository({ knex, fakeWaitHoursMultiplier })
                 return;
             }
             await knex.transaction(async (trx) => {
+                const revisionIds = new Set();
+                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();
                 for (const [id, { deliveredAt, openedAt, automationActionRevisionId }] of eventsByAutomatedEmailRecipientId) {
@@ -177,10 +185,11 @@ function createDatabaseAutomationsRepository({ knex, fakeWaitHoursMultiplier })
                         newOpensPerRevision.set(automationActionRevisionId, (newOpensPerRevision.get(automationActionRevisionId) ?? 0) + 1);
                     }
                 }
-                // 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({
@@ -189,24 +198,17 @@ function createDatabaseAutomationsRepository({ knex, fakeWaitHoursMultiplier })
                 }
             });
         },
-        async trackEmailClicked({ automationActionRevisionId, memberId, clickedAt }, { transacting } = {}) {
+        async trackEmailClicked({ automationActionRevisionId, automationRunStepId, memberId, clickedAt }, { transacting } = {}) {
             const trackClick = async (trx) => {
-                // Match recordEmailSent's lock order to avoid deadlocks.
-                await trx('automation_action_revisions')
-                    .select('id')
-                    .where({ id: automationActionRevisionId })
-                    .forUpdate()
-                    .first();
+                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
                 })
-                    .where('created_at', '<=', (0, database_date_1.toDatabaseDate)(clickedAt))
-                    .orderBy('created_at', 'desc')
-                    .orderBy('id', 'desc')
                     .forUpdate()
                     .first();
                 if (!recipient || recipient.clicked_at !== null) {
@@ -233,6 +235,23 @@ function createDatabaseAutomationsRepository({ knex, fakeWaitHoursMultiplier })
         }
     };
 }
+/**
+ * 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, revisionIds) {
+    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

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

@@ -276,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,
@@ -301,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>();
 
@@ -327,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({
@@ -341,25 +351,18 @@ export function createDatabaseAutomationsRepository({
             });
         },
 
-        async trackEmailClicked({automationActionRevisionId, memberId, clickedAt}, {transacting} = {}) {
+        async trackEmailClicked({automationActionRevisionId, automationRunStepId, memberId, clickedAt}, {transacting} = {}) {
             const trackClick = async (trx: Knex.Transaction) => {
-                // Match recordEmailSent's lock order to avoid deadlocks.
-                await trx('automation_action_revisions')
-                    .select('id')
-                    .where({id: automationActionRevisionId})
-                    .forUpdate()
-                    .first();
+                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
                     })
-                    .where('created_at', '<=', toDatabaseDate(clickedAt))
-                    .orderBy('created_at', 'desc')
-                    .orderBy('id', 'desc')
                     .forUpdate()
                     .first();
 
@@ -394,6 +397,29 @@ export function createDatabaseAutomationsRepository({
     };
 }
 
+/**
+ * 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

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')}`;
+}