ghost 6.61.0 → 6.63.0

package/core/server/services/email-service/README.md

@@ -0,0 +1,42 @@
+# Email service
+
+Renders newsletter emails, splits them into recipient batches, and submits the
+batches to the configured email provider. Domain terms live in
+[CONTEXT.md](CONTEXT.md).
+
+## Sending status
+
+The sending status served by the Admin API's `emails/:id/status` endpoint is
+derived on read. `sending-status.ts` owns the derivation from an email and its
+batches with their recipient counts; `SendingStatusService` reads those rows
+and `sending-status-serializers.ts` shapes the response. Submitted is terminal and the batch aggregation only
+describes a send that is still in progress or has failed, so submitted emails answer with the email's stored
+`email_count` as both completed and total; batch creation reconciles that
+column to the recipient rows it built. That also keeps reads of long-finished
+emails cheap, with no query over the batches or recipients. The endpoint is always available; Admin decides
+whether to poll it while a send is active.
+
+The phase is read from the batches: an email is submitting once any batch has
+left `pending`, and preparing otherwise. Batch statuses persist across
+attempts, so a retried email reports submitting with frozen progress while it
+waits for its job, and `failed_during` is the same derivation applied to a
+failed email.
+
+The rough ETA measures recent recipient throughput, including work completed by
+concurrent workers. It stays `null` until enough timing samples are available in
+the current phase and attempt, so short sends may finish without showing an ETA.
+Progress counts update independently of the estimate.
+
+The ETA is always `null` for failed emails and `0` once no work remains in the
+current phase. Batches that failed during the current attempt are not remaining
+work until the email is retried, so the ETA can reach `0` while completed is
+still below total. Consumers should key completion on the status, never the ETA.
+
+Ghost does not record when a sending attempt or phase started, so the ETA uses
+the email's `updated_at` as a proxy for the start of the current attempt: the
+sending job saves the email when it takes its status lock and, when the
+recipient count changed, again after creating batches; a retry or boot resume
+saves it when re-queuing the email. Batches completed before that timestamp
+belong to an earlier attempt and are left out of the rate window. The proxy
+only holds while nothing saves the Email model, or sets `emails.updated_at`
+through a raw update, while batches are being submitted.

package/core/server/services/email-service/batch-sending-service.js

@@ -33,7 +33,6 @@ class BatchSendingService {
   #models;
   #db;
   #sentry;
-  #debugStorageFilePath;
   #getRequiredUrlRelations;
   #shuttingDown = false;
   #inFlight = new Set();
@@ -68,7 +67,6 @@ class BatchSendingService {
    * @param {object} [dependencies.BEFORE_RETRY_CONFIG]
    * @param {object} [dependencies.AFTER_RETRY_CONFIG]
    * @param {object} [dependencies.MAILGUN_API_RETRY_CONFIG]
-   * @param {string} [dependencies.debugStorageFilePath]
    */
   constructor({
     emailRenderer,
@@ -83,7 +81,6 @@ class BatchSendingService {
     BEFORE_RETRY_CONFIG,
     AFTER_RETRY_CONFIG,
     MAILGUN_API_RETRY_CONFIG,
-    debugStorageFilePath,
   }) {
     this.#emailRenderer = emailRenderer;
     this.#sendingService = sendingService;
@@ -93,7 +90,6 @@ class BatchSendingService {
     this.#models = models;
     this.#db = db;
     this.#sentry = sentry;
-    this.#debugStorageFilePath = debugStorageFilePath;
     this.#getRequiredUrlRelations = getRequiredUrlRelations;
 
     if (BEFORE_RETRY_CONFIG) {
@@ -217,6 +213,7 @@ class BatchSendingService {
 
     // Check if email is 'pending' only + change status to submitting in one transaction.
     // This allows us to have a lock around the email job that makes sure an email can only have one active job.
+    // Also stamps updated_at, which SendingStatusService reads as the attempt start; do not save the Email once batches submit.
     let email;
     try {
       email = await this.retryDb(
@@ -708,6 +705,7 @@ class BatchSendingService {
     const deliveryTimes = this.calculateDeliveryTimes(email, batches.length);
 
     // Loop batches and send them via the EmailProvider
+    // SendingStatusService treats a batch that fails in this run as finished work; never re-queue it within the run.
     let succeededCount = 0;
     const queue = batches.slice();
 

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

@@ -1,6 +1,8 @@
 const errors = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
 
+/** @typedef {import('./sending-status-service').SendingStatusService} SendingStatusService */
+
 const messages = {
   postNotFound: 'Post not found.',
   noEmailsProvided: 'No emails provided.',
@@ -23,16 +25,18 @@ class EmailController {
   service;
   models;
   getRequiredUrlRelations;
+  sendingStatusService;
 
   /**
    *
    * @param {EmailService} service
-   * @param {{models: {Post: any, Newsletter: any, Email: any}, getRequiredUrlRelations?: () => string[]}} dependencies
+   * @param {{models: {Post: any, Newsletter: any, Email: any}, getRequiredUrlRelations?: () => string[], sendingStatusService: SendingStatusService}} dependencies
    */
-  constructor(service, { models, getRequiredUrlRelations = () => [] }) {
+  constructor(service, { models, getRequiredUrlRelations = () => [], sendingStatusService }) {
     this.service = service;
     this.models = models;
     this.getRequiredUrlRelations = getRequiredUrlRelations;
+    this.sendingStatusService = sendingStatusService;
   }
 
   async _getFrameData(frame) {
@@ -143,6 +147,18 @@ class EmailController {
 
     return await this.service.retryEmail(email);
   }
+
+  async getSendingStatus(frame) {
+    const status = await this.sendingStatusService.statusFor(frame.data.id);
+
+    if (!status) {
+      throw new errors.NotFoundError({
+        message: tpl(messages.emailNotFound),
+      });
+    }
+
+    return status;
+  }
 }
 
 module.exports = EmailController;

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

@@ -13,7 +13,7 @@ function isUnsplashImage(url) {
 }
 const { DateTime } = require('luxon');
 const htmlToPlaintext = require('@tryghost/html-to-plaintext');
-const EmailAddressParser = require('../email-address/email-address-parser');
+const emailAddressParser = require('../email-address/email-address-parser');
 const { getEmailDesign } = require('../email-rendering/email-design');
 const { registerHelpers } = require('./helpers/register-helpers');
 const crypto = require('crypto');
@@ -229,6 +229,8 @@ function cheerioLoad(html) {
  * @prop {string} id
  * @prop {RegExp} token
  * @prop {(member: MemberLike) => string} getValue
+ * @prop {boolean} [trusted] - Value is server-generated, so it is inserted into the
+ *   html body as-is instead of being HTML-escaped. Defaults to false (escaped).
  */
 
 /**
@@ -337,7 +339,7 @@ class EmailRenderer {
   }
 
   #getRawFromAddress(post, newsletter) {
-    // Pass the raw name through; EmailAddressParser.stringify() is the single
+    // Pass the raw name through; emailAddressParser.stringify() is the single
     // point that escapes it for the RFC5322 quoted-string From header. Escaping
     // here too would double-escape (e.g. a title containing a double quote).
     let senderName = this.#settingsCache.get('title') || '';
@@ -394,7 +396,7 @@ class EmailRenderer {
       { useFallbackAddress },
     );
 
-    return EmailAddressParser.stringify(addresses.from);
+    return emailAddressParser.stringify(addresses.from);
   }
 
   /**
@@ -423,7 +425,7 @@ class EmailRenderer {
     );
 
     if (addresses.replyTo) {
-      return EmailAddressParser.stringify(addresses.replyTo);
+      return emailAddressParser.stringify(addresses.replyTo);
     }
     return null;
   }
@@ -920,18 +922,21 @@ class EmailRenderer {
         getValue: (member) => {
           return this.createUnsubscribeUrl(member.uuid, { newsletterUuid });
         },
+        trusted: true, // Server-generated URL, must not be HTML-escaped
       },
       {
         id: 'manage_account_url',
         getValue: () => {
           return this.createManageAccountUrl();
         },
+        trusted: true, // Server-generated URL, must not be HTML-escaped
       },
       {
         id: 'uuid',
         getValue: (member) => {
           return member.uuid;
         },
+        trusted: true, // Server-generated identifier
       },
       {
         id: 'key',
@@ -941,6 +946,7 @@ class EmailRenderer {
             .update(member.uuid)
             .digest('hex');
         },
+        trusted: true, // Server-generated hmac
       },
       {
         id: 'first_name',
@@ -1000,6 +1006,7 @@ class EmailRenderer {
           return this.createUnsubscribeUrl(member.uuid, { newsletterUuid });
         },
         required: true, // Used in email headers
+        trusted: true, // Server-generated URL, must not be HTML-escaped
       },
       // Unique ID used for ad images to bypass ESP image proxies
       {
@@ -1007,6 +1014,7 @@ class EmailRenderer {
         getValue: () => {
           return crypto.randomUUID();
         },
+        trusted: true, // Server-generated identifier
       },
     ];
 
@@ -1043,6 +1051,7 @@ class EmailRenderer {
             getValue: fallback
               ? (member) => definition.getValue(member) || fallback
               : definition.getValue,
+            trusted: definition.trusted === true,
           });
         }
       }
@@ -1056,6 +1065,7 @@ class EmailRenderer {
           originalId: definition.id,
           token: new RegExp(`%%\\{${definition.id}\\}%%`, 'g'),
           getValue: definition.getValue,
+          trusted: definition.trusted === true,
         });
       }
     }

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

@@ -1,5 +1,4 @@
 const debug = require('@tryghost/debug')('i18n');
-const logging = require('@tryghost/logging');
 const url = require('../../api/endpoints/utils/serializers/output/utils/url');
 const events = require('../../lib/common/events');
 
@@ -25,6 +24,7 @@ class EmailServiceWrapper {
     const EmailRenderer = require('./email-renderer');
     const SendingService = require('./sending-service');
     const BatchSendingService = require('./batch-sending-service');
+    const { SendingStatusService } = require('./sending-status-service');
     const EmailSegmenter = require('./email-segmenter');
     const MailgunEmailProvider = require('./mailgun-email-provider');
     const { DomainWarmingService } = require('./domain-warming-service');
@@ -55,12 +55,6 @@ class EmailServiceWrapper {
     const emailAnalyticsJobs = require('../email-analytics/jobs');
     const { cachedImageSizeFromUrl } = require('../../lib/image');
 
-    // capture errors from mailgun client and log them in sentry
-    const errorHandler = (error) => {
-      logging.info(`Capturing error for mailgun email provider service`);
-      sentry.captureException(error);
-    };
-
     // Mailgun client instance for email provider
     const mailgunClient = new MailgunClient({
       config: configService,
@@ -78,7 +72,6 @@ class EmailServiceWrapper {
     const mailgunEmailProvider = new MailgunEmailProvider({
       mailgunClient,
       config: configService,
-      errorHandler,
     });
 
     const emailRenderer = new EmailRenderer({
@@ -134,8 +127,8 @@ class EmailServiceWrapper {
       db,
       sentry,
       getRequiredUrlRelations,
-      debugStorageFilePath: configService.getContentPath('data'),
     });
+    const sendingStatusService = new SendingStatusService({ knex: db.knex });
 
     if (ghostServer) {
       // Two phases: stop claiming batches immediately, drain in-flight ones later.
@@ -178,6 +171,7 @@ class EmailServiceWrapper {
         Email,
       },
       getRequiredUrlRelations,
+      sendingStatusService,
     });
   }
 }

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

@@ -1,6 +1,7 @@
 const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
 const debug = require('@tryghost/debug')('email-service:mailgun-provider-service');
+const { escapeExpression } = require('handlebars');
 
 /**
  * @typedef {object} Config
@@ -35,35 +36,41 @@ const debug = require('@tryghost/debug')('email-service:mailgun-provider-service
 class MailgunEmailProvider {
   #mailgunClient;
   #config;
-  #errorHandler;
 
   /**
    * @param {object} dependencies
    * @param {import('../lib/mailgun-client')} dependencies.mailgunClient - mailgun client to send emails
    * @param {Config} dependencies.config
-   * @param {Function} [dependencies.errorHandler] - custom error handler for logging exceptions
    */
-  constructor({ mailgunClient, config, errorHandler }) {
+  constructor({ mailgunClient, config }) {
     this.#mailgunClient = mailgunClient;
     this.#config = config;
-    this.#errorHandler = errorHandler;
   }
 
-  #createRecipientData(replacements) {
+  #createRecipientData(replacements, htmlEscapedIds) {
     let recipientData = {};
 
     recipientData = replacements.reduce((acc, replacement) => {
       const { id, value } = replacement;
       acc[id] = value;
+      // Mailgun's recipient-variables substitution is a simple string replace with
+      // no HTML awareness, and the same value is used for both the html and plaintext
+      // bodies. Member-controlled values get an extra, escaped variant that only the
+      // html body points at. Trusted server-generated values (urls, uuids, hmacs) are
+      // skipped so their URLs don't end up entity-encoded inside hrefs.
+      if (htmlEscapedIds.has(id)) {
+        acc[`${id}_html`] = typeof value === 'string' ? escapeExpression(value) : value;
+      }
       return acc;
     }, {});
 
     return recipientData;
   }
 
-  #updateRecipientVariables(data, replacementDefinitions) {
+  #updateRecipientVariables(data, replacementDefinitions, isHtml) {
     for (const def of replacementDefinitions) {
-      data = data.replace(def.token, `%recipient.${def.id}%`);
+      const useHtmlVariant = isHtml && !def.trusted;
+      data = data.replace(def.token, `%recipient.${def.id}${useHtmlVariant ? '_html' : ''}%`);
     }
     return data;
   }
@@ -128,8 +135,11 @@ class MailgunEmailProvider {
       }
 
       // create recipient data for Mailgun using replacement definitions
+      const htmlEscapedIds = new Set(
+        replacementDefinitions.filter((def) => !def.trusted).map((def) => def.id),
+      );
       const recipientData = recipients.reduce((acc, recipient) => {
-        acc[recipient.email] = this.#createRecipientData(recipient.replacements);
+        acc[recipient.email] = this.#createRecipientData(recipient.replacements, htmlEscapedIds);
         return acc;
       }, {});
 
@@ -139,6 +149,7 @@ class MailgunEmailProvider {
           messageData[key] = this.#updateRecipientVariables(
             messageData[key],
             replacementDefinitions,
+            key === 'html',
           );
         }
       });
@@ -165,7 +176,7 @@ class MailgunEmailProvider {
           message: this.#createMailgunErrorMessage(error),
           errorDetails: JSON.stringify({ error, messageData }),
           context: `Mailgun Error ${error.status}: ${error.details}`,
-          help: `https://ghost.org/docs/newsletters/#bulk-email-configuration`,
+          help: `https://docs.ghost.org/newsletters/#bulk-email-configuration`,
           code: 'BULK_EMAIL_SEND_FAILED',
         });
       } else {

package/core/server/services/email-service/sending-status-schema.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbBatchSendingRow = exports.DbEmailSendingRow = exports.StoredSendingStatus = void 0;
+const zod_1 = require("zod");
+const count_1 = require("../../lib/db-types/count");
+const date_1 = require("../../lib/db-types/date");
+exports.StoredSendingStatus = zod_1.z.enum(['pending', 'submitting', 'submitted', 'failed']);
+// Projections of tables the Bookshelf models own, not full rows, so there is no knex table
+// augmentation here: typing `emails` by these columns alone would mistype every other read.
+exports.DbEmailSendingRow = zod_1.z.object({
+    id: zod_1.z.string(),
+    status: exports.StoredSendingStatus,
+    email_count: count_1.DbCount,
+    updated_at: date_1.DbDate.nullable(),
+});
+exports.DbBatchSendingRow = zod_1.z.object({
+    status: exports.StoredSendingStatus,
+    created_at: date_1.DbDate,
+    updated_at: date_1.DbDate,
+    recipient_count: count_1.DbCount,
+});

package/core/server/services/email-service/sending-status-serializers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEmailStatusesResponse = void 0;
+const zod_1 = require("zod");
+const case_keys_1 = require("../../lib/case-keys");
+const sending_status_1 = require("./sending-status");
+const SendingPhaseResource = zod_1.z.enum(['preparing', 'submitting']);
+const SendingResource = zod_1.z.object({
+    status: zod_1.z.enum(['preparing', 'submitting', 'submitted', 'failed']),
+    progress: zod_1.z.object({
+        completed: zod_1.z.number(),
+        total: zod_1.z.number(),
+        estimated_seconds_remaining: zod_1.z.number().nullable(),
+    }),
+    failed_during: SendingPhaseResource.optional(),
+});
+const EmailStatusResource = zod_1.z.object({
+    id: zod_1.z.string(),
+    sending: SendingResource,
+});
+const EmailStatusesResponse = zod_1.z.object({ email_statuses: zod_1.z.array(EmailStatusResource) });
+exports.toEmailStatusesResponse = sending_status_1.EmailSendingStatus.transform(({ id, sending }) => ({
+    email_statuses: [
+        {
+            id,
+            sending: {
+                status: sending.status,
+                progress: (0, case_keys_1.snakeKeys)(sending.progress),
+                ...(sending.status === 'failed' ? { failed_during: sending.failedDuring } : {}),
+            },
+        },
+    ],
+})).pipe(EmailStatusesResponse);

package/core/server/services/email-service/sending-status-service.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendingStatusService = void 0;
+const case_keys_1 = require("../../lib/case-keys");
+const sending_status_schema_1 = require("./sending-status-schema");
+const sending_status_1 = require("./sending-status");
+class SendingStatusService {
+    #knex;
+    constructor({ knex }) {
+        this.#knex = knex;
+    }
+    async statusFor(emailId) {
+        const row = await this.#knex('emails')
+            .select('id', 'status', 'email_count', 'updated_at')
+            .where('id', emailId)
+            .first();
+        if (!row) {
+            return null;
+        }
+        const email = sending_status_schema_1.DbEmailSendingRow.parse(row);
+        // A submitted email answers from its own count, and batch creation reconciles email_count
+        // to the recipient rows it built, so the batch query is skipped rather than run and ignored.
+        const batches = email.status === 'submitted' ? [] : await this.#batchesFor(emailId);
+        return {
+            id: email.id,
+            sending: (0, sending_status_1.buildSendingStatus)({
+                status: email.status,
+                recipientCount: email.email_count,
+                // The sending job saves the email when it takes its status lock, so updated_at
+                // stands in for the attempt start that Ghost does not record.
+                attemptStartedAt: email.updated_at,
+            }, batches),
+        };
+    }
+    async #batchesFor(emailId) {
+        // Correlated per-batch count stays on the batch_id index; grouping recipients by email_id scans every recipient row.
+        const recipientCount = this.#knex('email_recipients as recipient')
+            .count('*')
+            .whereRaw('recipient.batch_id = batch.id');
+        const rows = await this.#knex('email_batches as batch')
+            .select('batch.status', 'batch.created_at', 'batch.updated_at')
+            .select(recipientCount.as('recipient_count'))
+            .where('batch.email_id', emailId);
+        return rows.map((batchRow) => (0, case_keys_1.camelKeys)(sending_status_schema_1.DbBatchSendingRow.parse(batchRow)));
+    }
+}
+exports.SendingStatusService = SendingStatusService;

package/core/server/services/email-service/sending-status.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailSendingStatus = exports.SendingStatus = exports.SendingProgress = exports.SendingPhase = void 0;
+exports.buildSendingStatus = buildSendingStatus;
+const zod_1 = require("zod");
+const ETA_COMPLETION_WINDOW = 20;
+const ETA_MIN_INTERVALS = 2;
+exports.SendingPhase = zod_1.z.enum(['preparing', 'submitting']);
+exports.SendingProgress = zod_1.z.object({
+    completed: zod_1.z.number().int().nonnegative(),
+    total: zod_1.z.number().int().nonnegative(),
+    estimatedSecondsRemaining: zod_1.z.number().int().nonnegative().nullable(),
+});
+exports.SendingStatus = zod_1.z.discriminatedUnion('status', [
+    zod_1.z.object({ status: exports.SendingPhase, progress: exports.SendingProgress }),
+    zod_1.z.object({ status: zod_1.z.literal('submitted'), progress: exports.SendingProgress }),
+    zod_1.z.object({ status: zod_1.z.literal('failed'), progress: exports.SendingProgress, failedDuring: exports.SendingPhase }),
+]);
+exports.EmailSendingStatus = zod_1.z.object({
+    id: zod_1.z.string(),
+    sending: exports.SendingStatus,
+});
+function buildSendingStatus(email, batches) {
+    // Submitted is terminal: every batch was accepted, so the email's own recipient count is the
+    // answer and the batch aggregation below, which describes a send still in progress, does not apply.
+    if (email.status === 'submitted') {
+        return {
+            status: 'submitted',
+            progress: {
+                completed: email.recipientCount,
+                total: email.recipientCount,
+                estimatedSecondsRemaining: 0,
+            },
+        };
+    }
+    const phase = batches.some((batch) => batch.status !== 'pending')
+        ? 'submitting'
+        : 'preparing';
+    const attemptStartedAt = email.attemptStartedAt?.getTime() ?? null;
+    const preparedCount = sumRecipients(batches);
+    const completedBatches = phase === 'preparing' ? batches : batches.filter((batch) => batch.status === 'submitted');
+    const completed = sumRecipients(completedBatches);
+    const total = phase === 'preparing' ? Math.max(email.recipientCount, preparedCount) : preparedCount;
+    if (email.status === 'failed') {
+        return {
+            status: 'failed',
+            progress: { completed, total, estimatedSecondsRemaining: null },
+            failedDuring: phase,
+        };
+    }
+    const failedThisAttempt = batches.filter((batch) => failedDuringAttempt(batch, attemptStartedAt));
+    const remaining = total - completed - sumRecipients(failedThisAttempt);
+    const samples = completedBatches.map((batch) => ({
+        recipientCount: batch.recipientCount,
+        timestamp: (phase === 'preparing' ? batch.createdAt : batch.updatedAt).getTime(),
+    }));
+    return {
+        status: phase,
+        progress: {
+            completed,
+            total,
+            estimatedSecondsRemaining: estimateSecondsRemaining({
+                remaining,
+                samples,
+                attemptStartedAt,
+            }),
+        },
+    };
+}
+function sumRecipients(batches) {
+    return batches.reduce((sum, batch) => sum + batch.recipientCount, 0);
+}
+// A batch that fails is only retried together with its email, so within an attempt it is finished work.
+function failedDuringAttempt(batch, attemptStartedAt) {
+    return (batch.status === 'failed' &&
+        attemptStartedAt !== null &&
+        batch.updatedAt.getTime() >= attemptStartedAt);
+}
+function estimateSecondsRemaining({ remaining, samples, attemptStartedAt, }) {
+    if (remaining <= 0) {
+        return 0;
+    }
+    const sorted = samples
+        .filter((sample) => sample.recipientCount > 0 &&
+        (attemptStartedAt === null || sample.timestamp >= attemptStartedAt))
+        .sort((a, b) => a.timestamp - b.timestamp);
+    // Coalesce completions sharing a timestamp so database timestamp precision does
+    // not turn their recipients into zero-duration samples or make row order matter.
+    const completions = [];
+    for (const sample of sorted) {
+        const previous = completions.at(-1);
+        if (previous?.timestamp === sample.timestamp) {
+            previous.recipientCount += sample.recipientCount;
+        }
+        else {
+            completions.push({ ...sample });
+        }
+    }
+    // Limit usable timestamps, not rows: fast sends may finish many batches per timestamp.
+    const window = completions.slice(-ETA_COMPLETION_WINDOW);
+    // Three distinct timestamps provide two measured intervals for an initial rate.
+    if (window.length < ETA_MIN_INTERVALS + 1) {
+        return null;
+    }
+    // Measure combined throughput across the window, including overlapping workers.
+    // The first completion is only the baseline: its recipients were processed
+    // before the measured time span.
+    const seconds = (window[window.length - 1].timestamp - window[0].timestamp) / 1000;
+    const recipients = window.slice(1).reduce((sum, sample) => sum + sample.recipientCount, 0);
+    return Math.ceil((remaining * seconds) / recipients);
+}

package/core/server/services/email-suppression-list/email-suppression-list.js

@@ -54,38 +54,6 @@ class EmailSuppressionData {
   }
 }
 
-/**
- * @abstract
- * @implements {IEmailSuppressionList}
- */
-class AbstractEmailSuppressionList {
-  /**
-   * @param {string} email
-   * @returns {Promise<boolean>}
-   */
-  // eslint-disable-next-line
-  async removeEmail(email) {
-    return Promise.reject();
-  }
-
-  /**
-   * @param {string} email
-   * @returns {Promise<EmailSuppressionData>}
-   */
-  // eslint-disable-next-line
-  async getSuppressionData(email) {
-    return Promise.reject();
-  }
-
-  /**
-   * @param {string[]} emails
-   * @returns {Promise<EmailSuppressionData[]>}
-   */
-  async getBulkSuppressionData(emails) {
-    return Promise.all(emails.map((email) => this.getSuppressionData(email)));
-  }
-}
-
 class EmailSuppressedEvent {
   /**
    * @readonly
@@ -120,7 +88,6 @@ class EmailSuppressedEvent {
 }
 
 module.exports = {
-  AbstractEmailSuppressionList,
   EmailSuppressionData,
   EmailSuppressedEvent,
 };

package/core/server/services/email-suppression-list/mailgun-email-suppression-list.js

@@ -1,13 +1,10 @@
-const {
-  AbstractEmailSuppressionList,
-  EmailSuppressionData,
-  EmailSuppressedEvent,
-} = require('./email-suppression-list');
+const { EmailSuppressionData, EmailSuppressedEvent } = require('./email-suppression-list');
 const { SpamComplaintEvent } = require('../email-service/events/spam-complaint-event');
 const { EmailBouncedEvent } = require('../email-service/events/email-bounced-event');
 const DomainEvents = require('@tryghost/domain-events');
 const logging = require('@tryghost/logging');
 const models = require('../../models');
+/** @import {IEmailSuppressionList} from './email-suppression-list' */
 
 /**
  * @typedef {object} IMailgunAPIClient
@@ -16,14 +13,16 @@ const models = require('../../models');
  * @prop {(email: string) => Promise<any>} removeUnsubscribe
  */
 
-class MailgunEmailSuppressionList extends AbstractEmailSuppressionList {
+/**
+ * @implements {IEmailSuppressionList}
+ */
+class MailgunEmailSuppressionList {
   /**
    * @param {object} deps
    * @param {import('bookshelf').Model} deps.Suppression
    * @param {IMailgunAPIClient} deps.apiClient
    */
   constructor(deps) {
-    super();
     this.Suppression = deps.Suppression;
     this.apiClient = deps.apiClient;
   }