ghost 6.53.0 → 6.54.1

package/core/server/services/adapter-manager/index.ts

@@ -1,37 +1,43 @@
-import GhostStorageBase from 'ghost-storage-base';
+import {StorageBase} from 'ghost-storage-base';
 import {SchedulingBase} from '@tryghost/adapter-base-scheduling';
 import {SSOBase} from '@tryghost/adapter-base-sso';
-import BaseCache from '@tryghost/adapter-base-cache';
-import { RedirectsStoreBase } from '@tryghost/adapter-base-redirects';
-import { RouteSettingsStoreBase } from '@tryghost/adapter-base-route-settings';
+import {CacheBase} from '@tryghost/adapter-base-cache';
+import {RedirectsStoreBase} from '@tryghost/adapter-base-redirects';
+import {RouteSettingsStoreBase} from '@tryghost/adapter-base-route-settings';
 
 import {AdapterManager} from './adapter-manager';
 import config from '../../../shared/config';
 
+const adapterPaths = new Set<string>([
+    '', // A blank path will cause us to check node_modules for the adapter
+    config.get('paths').internalAdaptersPath,
+
+    // custom docker builds may install adapters in a separate path from content,
+    // since the content dir is often bind-mounted into the container. Offering
+    // an escape hatch here to allow for this
+    config.get('paths').installedAdaptersPath ?? '',
+
+    // load adapters from content last, so that they don't override any other
+    // internal or platform-installed adapters
+    // TODO: potentially deprecate/remove as part of Ghost 7.0
+    config.getContentPath('adapters'),
+]);
+
 // A singleton adapter manager, preconfigured with the base classes for every
 // known adapter type. `getAdapter` resolves the active adapter and its options
 // from config on each call, so runtime config changes are always reflected.
 const adapterManager = new AdapterManager({
     loadAdapterFromPath: require,
     config,
-    pathsToAdapters: [
-        '', // A blank path will cause us to check node_modules for the adapter
-        config.getContentPath('adapters'),
-        config.get('paths').internalAdaptersPath
-    ],
+    pathsToAdapters: Array.from(adapterPaths),
     baseClasses: {
-        storage: GhostStorageBase,
+        storage: StorageBase,
         scheduling: SchedulingBase,
         sso: SSOBase,
-        cache: BaseCache,
+        cache: CacheBase,
         redirects: RedirectsStoreBase,
         'route-settings': RouteSettingsStoreBase
     }
 });
 
-// NOTE: exported via `module.exports` (rather than ESM named exports) so that
-// consumers keep `require(...).getAdapter` access AND tests can stub methods
-// with sinon — ESM named exports compile to immutable bindings that sinon
-// cannot stub. Using `module.exports` directly (not `export =`) keeps this
-// compatible with the erasableSyntaxOnly compiler option.
-module.exports = adapterManager;
+export default adapterManager;

package/core/server/services/adapter-manager/utils.js

@@ -1,9 +1,106 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAdapterEntryPoint = resolveAdapterEntryPoint;
 exports.resolveAdapterExport = resolveAdapterExport;
 exports.normalizeAdapterConfig = normalizeAdapterConfig;
 exports.getConfiguredFeatures = getConfiguredFeatures;
 exports.resolveAdapterOptions = resolveAdapterOptions;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_module_1 = require("node:module");
+/**
+* Whether `filePath` resolves to a location inside `directory`.
+*
+* Both sides are resolved through `fs.realpathSync` before comparing, because
+* Node's module resolution returns realpaths — so a symlinked install (or macOS'
+* `/var` -> `/private/var`) would otherwise look like an escape.
+*/
+function isContainedBy(filePath, directory) {
+    let realFilePath;
+    let realDirectory;
+    try {
+        realFilePath = node_fs_1.default.realpathSync(filePath);
+        realDirectory = node_fs_1.default.realpathSync(directory);
+    }
+    catch {
+        return false;
+    }
+    const relative = node_path_1.default.relative(realDirectory, realFilePath);
+    // Compare the first segment exactly rather than using startsWith('..'), so
+    // a legitimately-contained entry whose name merely begins with dots (e.g.
+    // "..hidden.js") isn't mistaken for traversal.
+    const [firstSegment] = relative.split(node_path_1.default.sep);
+    return relative !== '' && firstSegment !== '..' && !node_path_1.default.isAbsolute(relative);
+}
+/**
+* Map a candidate adapter path to the module Node should actually load.
+*
+* An adapter installed into `content/adapters` can be a full module directory
+* with its own `package.json`. Node's CommonJS directory resolution honours
+* `main` but ignores `exports` — per spec, `exports` applies only to package
+* specifiers resolved through `node_modules`, never to directory paths — so a
+* package declaring only `exports` would otherwise fail to resolve.
+*
+* We get native `exports` resolution by self-referencing: because the referrer
+* we hand to `createRequire` sits inside the package, requiring the package by
+* its own `name` makes Node resolve through that package's own `exports` field,
+* applying conditions, nesting and subpath rules for us.
+*
+* Anything that isn't a self-referencing module directory — a bare
+* `node_modules` specifier, a plain `index.js` adapter directory, or a package
+* declaring only `main` — is returned untouched so Node's own resolution
+* applies, preserving the behaviour of pre-existing adapters.
+*
+* @NOTE: `require` matches the `require`, `node` and `default` conditions but
+* never `import`, and that isn't overridable (`--conditions` only adds custom
+* conditions). So an ESM-only package whose root export is conditioned solely on
+* `import` (`{".": {"import": "./dist/index.js"}}`) is not resolvable here, even
+* though `require()` would happily load the file it points at. Such a package
+* needs a `require`, `node`, `default` or unconditioned target. Lifting this
+* would mean reading the `exports` field ourselves.
+*/
+function resolveAdapterEntryPoint(pathToAdapter) {
+    // The node_modules lane passes a bare specifier rather than a path — Node
+    // already applies `exports` to those — and a relative read here would be
+    // resolved against the cwd, so only absolute directories are considered.
+    if (!node_path_1.default.isAbsolute(pathToAdapter)) {
+        return pathToAdapter;
+    }
+    const manifestPath = node_path_1.default.join(pathToAdapter, 'package.json');
+    let name;
+    try {
+        ({ name } = JSON.parse(node_fs_1.default.readFileSync(manifestPath, 'utf8')));
+    }
+    catch {
+        // Not a module directory, or an unreadable/malformed manifest.
+        return pathToAdapter;
+    }
+    // Self-referencing requires a package name to reference.
+    if (typeof name !== 'string' || !name) {
+        return pathToAdapter;
+    }
+    try {
+        const resolved = (0, node_module_1.createRequire)(manifestPath).resolve(name);
+        // Self-referencing only kicks in when the package declares `exports`.
+        // Without it, Node falls back to walking `node_modules` up the tree and
+        // can resolve a *different*, same-named package from elsewhere in the
+        // install — silently loading an impostor instead of the operator's
+        // adapter. Only accept a result that actually lives in the adapter
+        // directory; anything else falls back to Node's directory resolution.
+        if (!isContainedBy(resolved, pathToAdapter)) {
+            return pathToAdapter;
+        }
+        return resolved;
+    }
+    catch {
+        // No usable `exports` entry — fall back to Node's directory resolution,
+        // which still handles `main` and `index.js`.
+        return pathToAdapter;
+    }
+}
 /**
 * Resolve an adapter export to a constructor function, handling both CommonJS and ES module formats.
 */
@@ -34,19 +131,23 @@ function getSchedulingConfig(config) {
     }
     return adapterConfig;
 }
-function normalizeFilestoreConfig(config, key, defaultPaths) {
+function normalizeAdapterPaths(config, key, defaultPathsByAdapter) {
     const adapterConfig = config.get(`adapters:${key}`);
-    if (!adapterConfig?.FileStore) {
+    if (!adapterConfig) {
         return adapterConfig;
     }
-    const fileStoreConfig = { ...adapterConfig.FileStore };
-    for (const [pathName, defaultPath] of Object.entries(defaultPaths)) {
-        fileStoreConfig[pathName] ||= defaultPath;
+    const normalized = { ...adapterConfig };
+    for (const [adapterClassName, defaultPaths] of Object.entries(defaultPathsByAdapter)) {
+        if (!normalized[adapterClassName]) {
+            continue;
+        }
+        const storeConfig = { ...normalized[adapterClassName] };
+        for (const [pathName, defaultPath] of Object.entries(defaultPaths)) {
+            storeConfig[pathName] ||= defaultPath;
+        }
+        normalized[adapterClassName] = storeConfig;
     }
-    return {
-        ...adapterConfig,
-        FileStore: fileStoreConfig
-    };
+    return normalized;
 }
 /**
 * Normalize adapter config by ensuring that feature-specific adapter configs
@@ -58,12 +159,21 @@ function normalizeAdapterConfig(config) {
         ...adapterConfig,
         storage: adapterConfig?.storage ?? config.get('storage'),
         scheduling: getSchedulingConfig(config),
-        redirects: normalizeFilestoreConfig(config, 'redirects', {
-            basePath: config.getContentPath('data')
+        redirects: normalizeAdapterPaths(config, 'redirects', {
+            FileStore: {
+                basePath: config.getContentPath('data')
+            }
         }),
-        'route-settings': normalizeFilestoreConfig(config, 'route-settings', {
-            basePath: config.getContentPath('settings'),
-            defaultSettingsBasePath: config.get('paths:defaultRouteSettings')
+        'route-settings': normalizeAdapterPaths(config, 'route-settings', {
+            FileStore: {
+                basePath: config.getContentPath('settings'),
+                defaultSettingsBasePath: config.get('paths:defaultRouteSettings')
+            },
+            // The S3 store reads the bundled defaults off disk too, for the
+            // empty-state response when the bucket holds no routes.yaml yet.
+            S3RouteSettingsStore: {
+                defaultSettingsBasePath: config.get('paths:defaultRouteSettings')
+            }
         }),
     };
 }

package/core/server/services/adapter-manager/utils.ts

@@ -1,6 +1,108 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {createRequire} from 'node:module';
 import type {AdapterConstructor} from "./types";
 import type {ConfigInstance} from '../../../shared/config/loader';
 
+/**
+* Whether `filePath` resolves to a location inside `directory`.
+*
+* Both sides are resolved through `fs.realpathSync` before comparing, because
+* Node's module resolution returns realpaths — so a symlinked install (or macOS'
+* `/var` -> `/private/var`) would otherwise look like an escape.
+*/
+function isContainedBy(filePath: string, directory: string): boolean {
+    let realFilePath: string;
+    let realDirectory: string;
+
+    try {
+        realFilePath = fs.realpathSync(filePath);
+        realDirectory = fs.realpathSync(directory);
+    } catch {
+        return false;
+    }
+
+    const relative = path.relative(realDirectory, realFilePath);
+
+    // Compare the first segment exactly rather than using startsWith('..'), so
+    // a legitimately-contained entry whose name merely begins with dots (e.g.
+    // "..hidden.js") isn't mistaken for traversal.
+    const [firstSegment] = relative.split(path.sep);
+
+    return relative !== '' && firstSegment !== '..' && !path.isAbsolute(relative);
+}
+
+/**
+* Map a candidate adapter path to the module Node should actually load.
+*
+* An adapter installed into `content/adapters` can be a full module directory
+* with its own `package.json`. Node's CommonJS directory resolution honours
+* `main` but ignores `exports` — per spec, `exports` applies only to package
+* specifiers resolved through `node_modules`, never to directory paths — so a
+* package declaring only `exports` would otherwise fail to resolve.
+*
+* We get native `exports` resolution by self-referencing: because the referrer
+* we hand to `createRequire` sits inside the package, requiring the package by
+* its own `name` makes Node resolve through that package's own `exports` field,
+* applying conditions, nesting and subpath rules for us.
+*
+* Anything that isn't a self-referencing module directory — a bare
+* `node_modules` specifier, a plain `index.js` adapter directory, or a package
+* declaring only `main` — is returned untouched so Node's own resolution
+* applies, preserving the behaviour of pre-existing adapters.
+*
+* @NOTE: `require` matches the `require`, `node` and `default` conditions but
+* never `import`, and that isn't overridable (`--conditions` only adds custom
+* conditions). So an ESM-only package whose root export is conditioned solely on
+* `import` (`{".": {"import": "./dist/index.js"}}`) is not resolvable here, even
+* though `require()` would happily load the file it points at. Such a package
+* needs a `require`, `node`, `default` or unconditioned target. Lifting this
+* would mean reading the `exports` field ourselves.
+*/
+export function resolveAdapterEntryPoint(pathToAdapter: string): string {
+    // The node_modules lane passes a bare specifier rather than a path — Node
+    // already applies `exports` to those — and a relative read here would be
+    // resolved against the cwd, so only absolute directories are considered.
+    if (!path.isAbsolute(pathToAdapter)) {
+        return pathToAdapter;
+    }
+
+    const manifestPath = path.join(pathToAdapter, 'package.json');
+
+    let name: unknown;
+    try {
+        ({name} = JSON.parse(fs.readFileSync(manifestPath, 'utf8')));
+    } catch {
+        // Not a module directory, or an unreadable/malformed manifest.
+        return pathToAdapter;
+    }
+
+    // Self-referencing requires a package name to reference.
+    if (typeof name !== 'string' || !name) {
+        return pathToAdapter;
+    }
+
+    try {
+        const resolved = createRequire(manifestPath).resolve(name);
+
+        // Self-referencing only kicks in when the package declares `exports`.
+        // Without it, Node falls back to walking `node_modules` up the tree and
+        // can resolve a *different*, same-named package from elsewhere in the
+        // install — silently loading an impostor instead of the operator's
+        // adapter. Only accept a result that actually lives in the adapter
+        // directory; anything else falls back to Node's directory resolution.
+        if (!isContainedBy(resolved, pathToAdapter)) {
+            return pathToAdapter;
+        }
+
+        return resolved;
+    } catch {
+        // No usable `exports` entry — fall back to Node's directory resolution,
+        // which still handles `main` and `index.js`.
+        return pathToAdapter;
+    }
+}
+
 /**
 * Resolve an adapter export to a constructor function, handling both CommonJS and ES module formats.
 */
@@ -37,21 +139,26 @@ function getSchedulingConfig(config: ConfigInstance) {
     return adapterConfig;
 }
 
-function normalizeFilestoreConfig(config: ConfigInstance, key: 'redirects' | 'route-settings', defaultPaths: Record<string, string>) {
+function normalizeAdapterPaths(config: ConfigInstance, key: 'redirects' | 'route-settings', defaultPathsByAdapter: Record<string, Record<string, string>>) {
     const adapterConfig = config.get(`adapters:${key}`);
-    if (!adapterConfig?.FileStore) {
+    if (!adapterConfig) {
         return adapterConfig;
     }
 
-    const fileStoreConfig = {...adapterConfig.FileStore};
-    for (const [pathName, defaultPath] of Object.entries(defaultPaths)) {
-        fileStoreConfig[pathName] ||= defaultPath;
-    }
+    const normalized = {...adapterConfig};
+    for (const [adapterClassName, defaultPaths] of Object.entries(defaultPathsByAdapter)) {
+        if (!normalized[adapterClassName]) {
+            continue;
+        }
 
-    return {
-        ...adapterConfig,
-        FileStore: fileStoreConfig
+        const storeConfig = {...normalized[adapterClassName]};
+        for (const [pathName, defaultPath] of Object.entries(defaultPaths)) {
+            storeConfig[pathName] ||= defaultPath;
+        }
+        normalized[adapterClassName] = storeConfig;
     }
+
+    return normalized;
 }
 
 /**
@@ -65,12 +172,21 @@ export function normalizeAdapterConfig(config: ConfigInstance) {
         ...adapterConfig,
         storage: adapterConfig?.storage ?? config.get('storage'),
         scheduling: getSchedulingConfig(config),
-        redirects: normalizeFilestoreConfig(config, 'redirects', {
-            basePath: config.getContentPath('data')
+        redirects: normalizeAdapterPaths(config, 'redirects', {
+            FileStore: {
+                basePath: config.getContentPath('data')
+            }
         }),
-        'route-settings': normalizeFilestoreConfig(config, 'route-settings', {
-            basePath: config.getContentPath('settings'),
-            defaultSettingsBasePath: config.get('paths:defaultRouteSettings')
+        'route-settings': normalizeAdapterPaths(config, 'route-settings', {
+            FileStore: {
+                basePath: config.getContentPath('settings'),
+                defaultSettingsBasePath: config.get('paths:defaultRouteSettings')
+            },
+            // The S3 store reads the bundled defaults off disk too, for the
+            // empty-state response when the bucket holds no routes.yaml yet.
+            S3RouteSettingsStore: {
+                defaultSettingsBasePath: config.get('paths:defaultRouteSettings')
+            }
         }),
     }
 }

package/core/server/services/api-version-compatibility/mw-version-rewrites.js

@@ -1,5 +1,5 @@
 const legacyApiPathMatch = require('./legacy-api-path-match');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 
 /**
  * If there is a version in the URL, and this is a valid API URL containing admin/content

package/core/server/services/audience-feedback/index.js

@@ -1,4 +1,4 @@
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const urlService = require('../../services/url');
 
 const AudienceFeedbackService = require('./audience-feedback-service');

package/core/server/services/auth/passwordreset.js

@@ -5,7 +5,7 @@ const tpl = require('@tryghost/tpl');
 const moment = require('moment');
 
 const models = require('../../models');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const mail = require('../mail');
 
 const messages = {

package/core/server/services/auth/session/express-session.js

@@ -3,7 +3,7 @@ const session = require('express-session');
 const config = require('../../../../shared/config');
 const settingsCache = require('../../../../shared/settings-cache');
 const models = require('../../../models');
-const urlUtils = require('../../../../shared/url-utils');
+const urlUtils = require('../../../../shared/url-utils').default;
 
 const SessionStore = require('./session-store');
 const sessionStore = new SessionStore(models.Session);

package/core/server/services/auth/session/index.js

@@ -1,4 +1,4 @@
-const adapterManager = require('../../adapter-manager');
+const adapterManager = require('../../adapter-manager').default;
 const createSessionService = require('./session-service');
 const sessionFromToken = require('./session-from-token');
 const createSessionMiddleware = require('./middleware');
@@ -9,7 +9,7 @@ const {t} = require('../../i18n');
 const expressSession = require('./express-session');
 
 const models = require('../../../models');
-const urlUtils = require('../../../../shared/url-utils');
+const urlUtils = require('../../../../shared/url-utils').default;
 const config = require('../../../../shared/config');
 const {blogIcon} = require('../../../lib/image');
 const url = require('url');

package/core/server/services/auth/session/session-service.js

@@ -58,7 +58,7 @@ const AUTH_CODE_CHALLENGE_BYTES = 16;
  * @param {() => string} deps.getBlogLogo
  * @param {import('../../mail').GhostMailer} deps.mailer
  * @param {import('../../i18n').t} deps.t
- * @param {import('../../../../shared/url-utils')} deps.urlUtils
+ * @param {import('../../../../shared/url-utils').default} deps.urlUtils
  * @param {() => boolean} deps.isStaffDeviceVerificationDisabled
  * @returns {SessionService}
  */
@@ -208,7 +208,34 @@ module.exports = function createSessionService({
      * @returns {Promise<void>}
      */
     async function createSessionForUser(req, res, user) {
-        const session = await getSession(req, res);
+        const previousSession = await getSession(req, res);
+
+        // Carried over to the new session so verification state survives login
+        const {
+            user_id: previousUserId,
+            verified: previousVerified,
+            auth_code_challenge: previousAuthCodeChallenge,
+            auth_code_generated_at: previousAuthCodeGeneratedAt
+        } = previousSession;
+
+        // Ensure a new session is always created
+        await new Promise((resolve, reject) => {
+            req.session.regenerate((err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+
+        const session = req.session;
+        session.user_id = previousUserId;
+        // A different user doesn't inherit the previous user's verification
+        session.verified = previousUserId && previousUserId !== user.id ? undefined : previousVerified;
+        session.auth_code_challenge = previousAuthCodeChallenge;
+        session.auth_code_generated_at = previousAuthCodeGeneratedAt;
+
         const origin = getOriginOfRequest(req);
         await assignUserToSession({
             session,

package/core/server/services/automations/automations-api.js

@@ -21,8 +21,6 @@ const bson_objectid_1 = __importDefault(require("bson-objectid"));
 const zod_1 = require("zod");
 const database_automations_repository_1 = require("./database-automations-repository");
 const fake_wait_hours_multiplier_1 = require("./fake-wait-hours-multiplier");
-// @ts-expect-error Models currently lack type definitions.
-const models_1 = require("../../models");
 const { knex } = require('../../data/db');
 const domainEvents = require('@tryghost/domain-events');
 const labs = require('../../../shared/labs');
@@ -49,8 +47,8 @@ const waitActionSchema = zod_1.z.object({
     type: zod_1.z.literal('wait'),
     data: zod_1.z.object({
         wait_hours: zod_1.z.number().int().positive()
-    }).strict()
-}).strict();
+    })
+});
 const sendEmailActionSchema = zod_1.z.object({
     id: objectIdSchema,
     type: zod_1.z.literal('send_email'),
@@ -58,12 +56,12 @@ const sendEmailActionSchema = zod_1.z.object({
         email_subject: zod_1.z.string(),
         email_lexical: zod_1.z.string(),
         email_design_setting_id: zod_1.z.string().min(1)
-    }).strict()
-}).strict();
+    })
+});
 const edgeSchema = zod_1.z.object({
     source_action_id: objectIdSchema,
     target_action_id: objectIdSchema
-}).strict();
+});
 const editAutomationDataSchema = zod_1.z.object({
     status: zod_1.z.enum(['active', 'inactive']),
     actions: zod_1.z.array(zod_1.z.discriminatedUnion('type', [
@@ -71,7 +69,7 @@ const editAutomationDataSchema = zod_1.z.object({
         sendEmailActionSchema
     ])).min(1).max(MAX_AUTOMATION_ACTIONS),
     edges: zod_1.z.array(edgeSchema)
-}).strict();
+});
 const repository = (0, database_automations_repository_1.createDatabaseAutomationsRepository)({
     knex,
     fakeWaitHoursMultiplier: (0, fake_wait_hours_multiplier_1.parseFakeWaitHoursMultiplier)(config.get('automations:fakeWaitHoursMultiplier'))
@@ -304,23 +302,8 @@ async function markStepTerminal(...args) {
 async function retryStep(...args) {
     return await repository.retryStep(...args);
 }
-async function recordEmailSent(options) {
-    await knex.transaction(async (transacting) => {
-        await models_1.AutomatedEmailRecipient.add({
-            member_id: options.memberId,
-            member_uuid: options.memberUuid,
-            member_email: options.memberEmail,
-            member_name: options.memberName,
-            automation_action_revision_id: options.automationActionRevisionId,
-            ...(options.mailgunMessageId ? { mailgun_message_id: options.mailgunMessageId } : {}),
-            track_opens: options.trackOpens
-        }, { transacting });
-        await transacting('automation_action_revisions')
-            .where('id', options.automationActionRevisionId)
-            .update({
-            email_sent_count: transacting.raw('COALESCE(??, 0) + ?', ['email_sent_count', 1])
-        });
-    });
+async function recordEmailSent(...args) {
+    return await repository.recordEmailSent(...args);
 }
 async function getAutomatedEmailRecipientsByMailgunIds(...args) {
     return await repository.getAutomatedEmailRecipientsByMailgunIds(...args);

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

@@ -2,15 +2,12 @@ import errors from '@tryghost/errors';
 import tpl from '@tryghost/tpl';
 import ObjectId from 'bson-objectid';
 import {z} from 'zod';
-import {type Knex} from 'knex';
 import {createDatabaseAutomationsRepository} from './database-automations-repository';
 import {parseFakeWaitHoursMultiplier} from './fake-wait-hours-multiplier';
 import type {
     AutomationsRepository,
     EditAutomationData
 } from './automations-repository';
-// @ts-expect-error Models currently lack type definitions.
-import {AutomatedEmailRecipient} from '../../models';
 
 const {knex} = require('../../data/db');
 const domainEvents = require('@tryghost/domain-events');
@@ -42,8 +39,8 @@ const waitActionSchema = z.object({
     type: z.literal('wait'),
     data: z.object({
         wait_hours: z.number().int().positive()
-    }).strict()
-}).strict();
+    })
+});
 
 const sendEmailActionSchema = z.object({
     id: objectIdSchema,
@@ -52,13 +49,13 @@ const sendEmailActionSchema = z.object({
         email_subject: z.string(),
         email_lexical: z.string(),
         email_design_setting_id: z.string().min(1)
-    }).strict()
-}).strict();
+    })
+});
 
 const edgeSchema = z.object({
     source_action_id: objectIdSchema,
     target_action_id: objectIdSchema
-}).strict();
+});
 
 const editAutomationDataSchema = z.object({
     status: z.enum(['active', 'inactive']),
@@ -67,7 +64,7 @@ const editAutomationDataSchema = z.object({
         sendEmailActionSchema
     ])).min(1).max(MAX_AUTOMATION_ACTIONS),
     edges: z.array(edgeSchema)
-}).strict();
+});
 
 const repository = createDatabaseAutomationsRepository({
     knex,
@@ -363,34 +360,8 @@ export async function retryStep(...args: Parameters<AutomationsRepository['retry
     return await repository.retryStep(...args);
 }
 
-export type RecordEmailSentOptions = Readonly<{
-    automationActionRevisionId: string;
-    mailgunMessageId?: string;
-    memberEmail: string;
-    memberId: string;
-    memberName: string | null;
-    memberUuid: string;
-    trackOpens: boolean;
-}>;
-
-export async function recordEmailSent(options: RecordEmailSentOptions): Promise<void> {
-    await knex.transaction(async (transacting: Knex.Transaction) => {
-        await AutomatedEmailRecipient.add({
-            member_id: options.memberId,
-            member_uuid: options.memberUuid,
-            member_email: options.memberEmail,
-            member_name: options.memberName,
-            automation_action_revision_id: options.automationActionRevisionId,
-            ...(options.mailgunMessageId ? {mailgun_message_id: options.mailgunMessageId} : {}),
-            track_opens: options.trackOpens
-        }, {transacting});
-
-        await transacting('automation_action_revisions')
-            .where('id', options.automationActionRevisionId)
-            .update({
-                email_sent_count: transacting.raw('COALESCE(??, 0) + ?', ['email_sent_count', 1])
-            });
-    });
+export async function recordEmailSent(...args: Parameters<AutomationsRepository['recordEmailSent']>) {
+    return await repository.recordEmailSent(...args);
 }
 
 export async function getAutomatedEmailRecipientsByMailgunIds(