ghost 6.62.0 → 6.64.0

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

@@ -0,0 +1,117 @@
+"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_WINDOW_MS = 60_000;
+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 });
+        }
+    }
+    // Three distinct timestamps provide two measured intervals for an initial rate.
+    if (completions.length < ETA_MIN_INTERVALS + 1) {
+        return null;
+    }
+    // Include the baseline at or before the last minute so the first interval's
+    // recipients have their full elapsed time. Sparse sends still need two intervals.
+    const cutoff = completions[completions.length - 1].timestamp - ETA_WINDOW_MS;
+    let baseline = completions.length - 1;
+    while (baseline > 0 && completions[baseline].timestamp > cutoff) {
+        baseline -= 1;
+    }
+    const window = completions.slice(Math.max(0, Math.min(baseline, completions.length - ETA_MIN_INTERVALS - 1)));
+    // 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;
   }

package/core/server/services/gifts/README.md

@@ -6,8 +6,8 @@ transactions, or Stripe objects.
 
 ## Interface
 
-- `startCheckout(input)` owns the `giftSubCustomization` flag, duration
-  catalogue, Portal plan gate, tier/cadence validation, authoritative price,
+- `startCheckout(input)` owns the duration catalogue, Portal plan gate,
+  tier/cadence validation, authoritative price,
   token, success parameters, metadata, customer, and one-time payment.
 - `preparePaidContinuation(input)` validates an active gift and returns the
   stable tier/cadence/trial decision consumed by the normal subscription

package/core/server/services/gifts/constants.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GIFT_DELIVERY_EMAIL_TAG = exports.GIFT_DELIVERY_STALE_AFTER_MS = exports.GIFT_REMINDER_FLOOR_DAYS = exports.GIFT_REMINDER_LEAD_DAYS = exports.GIFT_SEND_HOUR = exports.GIFT_MAX_SCHEDULE_DAYS = exports.GIFT_EXPIRY_DAYS = void 0;
 exports.GIFT_EXPIRY_DAYS = 365;
 // How far ahead a delivery may be scheduled. Portal's picker carries its own
-// copy (GIFT_MAX_SCHEDULE_DAYS in beta-gift-page.tsx) since Portal ships
+// copy (GIFT_MAX_SCHEDULE_DAYS in gift-page.tsx) since Portal ships
 // separately — change them together.
 exports.GIFT_MAX_SCHEDULE_DAYS = 365;
 // Site-local hour a scheduled delivery is sent at. Portal never derives

package/core/server/services/gifts/gift-email-service.js

@@ -13,6 +13,7 @@ const gift_date_1 = require("./gift-date");
 const DEFAULT_ACCENT_COLOR = '#15212A';
 class GiftEmailService {
     transactionalMailer;
+    config;
     bulkMailer;
     settingsCache;
     urlUtils;
@@ -21,7 +22,8 @@ class GiftEmailService {
     blogIcon;
     renderer;
     t;
-    constructor({ transactionalMailer, bulkMailer, settingsCache, urlUtils, getFromAddress, getReplyToAddress, blogIcon, t, }) {
+    constructor({ config, transactionalMailer, bulkMailer, settingsCache, urlUtils, getFromAddress, getReplyToAddress, blogIcon, t, }) {
+        this.config = config;
         this.transactionalMailer = transactionalMailer;
         this.bulkMailer = bulkMailer;
         this.settingsCache = settingsCache;
@@ -205,6 +207,11 @@ class GiftEmailService {
             buyerName,
             interpolation: { escapeValue: false },
         });
+        const tags = [constants_1.GIFT_DELIVERY_EMAIL_TAG];
+        const mailgunTagFromConfig = this.config.get('bulkEmail:mailgun:tag');
+        if (typeof mailgunTagFromConfig === 'string' && mailgunTagFromConfig.length > 0) {
+            tags.push(mailgunTagFromConfig);
+        }
         if (!this.bulkMailer.isConfigured()) {
             await this.transactionalMailer.send({
                 to: recipientEmail,
@@ -214,7 +221,7 @@ class GiftEmailService {
                 from: this.getFromAddress(),
                 replyTo: this.getReplyToAddress(),
                 forceTextContent: true,
-                tags: [constants_1.GIFT_DELIVERY_EMAIL_TAG],
+                tags,
                 disableTracking: true,
             });
             return { providerMessageId: null };
@@ -225,7 +232,7 @@ class GiftEmailService {
             plaintext: text,
             from: this.getFromAddress(),
             replyTo: this.getReplyToAddress(),
-            tags: [constants_1.GIFT_DELIVERY_EMAIL_TAG],
+            tags,
             disable_tracking: true,
         }, { [recipientEmail]: {} }, []);
         const providerMessageId = (0, mailgun_message_id_1.getMailgunMessageId)(response) ?? null;

package/core/server/services/gifts/gift-service.js

@@ -95,40 +95,22 @@ class GiftService {
         this.deps = deps;
     }
     async startCheckout(input) {
-        const customizationEnabled = this.deps.labsService.isSet('giftSubCustomization');
-        const populatedDeliveryFields = [
-            input.recipientEmail,
-            input.recipientName,
-            input.buyerName,
-            input.personalMessage,
-            input.deliveryDate,
-        ].some((value) => value !== undefined && value !== null && value !== '');
-        if (!customizationEnabled && (input.deliveryMethod === 'email' || populatedDeliveryFields)) {
-            throw new errors_1.default.BadRequestError({
-                message: 'Bad Request.',
-                context: 'Gift email delivery is not available',
-            });
-        }
         const parsedBuyerEmail = CheckoutBuyerEmailSchema.safeParse(input.buyer.email);
-        if (customizationEnabled && !parsedBuyerEmail.success) {
+        if (!parsedBuyerEmail.success) {
             throw new errors_1.default.BadRequestError({
                 message: 'Bad Request.',
                 context: `Invalid gift buyer email: ${parsedBuyerEmail.error.issues[0].message}`,
             });
         }
         const buyerEmail = parsedBuyerEmail.success ? parsedBuyerEmail.data : input.buyer.email;
-        const parsedDelivery = GiftCheckoutDeliverySchema.safeParse(customizationEnabled
-            ? {
-                deliveryMethod: input.deliveryMethod ?? 'link',
-                recipientEmail: input.recipientEmail,
-                recipientName: input.recipientName,
-                buyerName: input.buyerName,
-                personalMessage: input.personalMessage,
-                deliveryDate: input.deliveryDate,
-            }
-            : {
-                deliveryMethod: 'link',
-            });
+        const parsedDelivery = GiftCheckoutDeliverySchema.safeParse({
+            deliveryMethod: input.deliveryMethod ?? 'link',
+            recipientEmail: input.recipientEmail,
+            recipientName: input.recipientName,
+            buyerName: input.buyerName,
+            personalMessage: input.personalMessage,
+            deliveryDate: input.deliveryDate,
+        });
         if (!parsedDelivery.success) {
             const issue = parsedDelivery.error.issues[0];
             throw new errors_1.default.BadRequestError({
@@ -150,22 +132,7 @@ class GiftService {
                 context: 'Expected offerId or tierId, received none',
             });
         }
-        let resolvedDuration = null;
-        let cadence;
-        if (customizationEnabled) {
-            resolvedDuration = (0, gift_checkout_offer_1.resolveGiftDuration)(input);
-            cadence = resolvedDuration.cadence;
-        }
-        else {
-            if (input.cadence !== 'month' && input.cadence !== 'year') {
-                const receivedCadence = input.cadence ? `"${input.cadence}"` : input.cadence;
-                throw new errors_1.default.BadRequestError({
-                    message: 'Bad Request.',
-                    context: `Expected cadence to be "month" or "year", received ${receivedCadence}`,
-                });
-            }
-            cadence = input.cadence;
-        }
+        const resolvedDuration = (0, gift_checkout_offer_1.resolveGiftDuration)(input);
         let tier;
         try {
             tier = await this.deps.tiersService.api.read(input.tierId);
@@ -185,20 +152,15 @@ class GiftService {
                 message: 'This tier is archived.',
             });
         }
-        let duration = 1;
-        let totalMonths;
-        let amount = tier.getPrice(cadence);
-        if (resolvedDuration) {
-            const plan = (0, gift_checkout_offer_1.validateGiftCheckoutOffer)({
-                tier,
-                portalPlans: this.deps.settingsCache.get('portal_plans'),
-                offer: resolvedDuration,
-            });
-            cadence = plan.cadence;
-            duration = plan.duration;
-            totalMonths = plan.totalMonths;
-            amount = plan.amount;
-        }
+        const plan = (0, gift_checkout_offer_1.validateGiftCheckoutOffer)({
+            tier,
+            portalPlans: this.deps.settingsCache.get('portal_plans'),
+            offer: resolvedDuration,
+        });
+        const cadence = plan.cadence;
+        const duration = plan.duration;
+        const totalMonths = plan.totalMonths;
+        const amount = plan.amount;
         const tierId = typeof tier.id === 'string' ? tier.id : tier.id.toHexString();
         const token = this.generateToken();
         const successUrl = new URL(input.successUrl);

package/core/server/services/gifts/index.js

@@ -34,7 +34,6 @@ function init(options) {
     const MailgunClient = require('../lib/mailgun-client');
     const config = require('../../../shared/config');
     const settingsCache = require('../../../shared/settings-cache');
-    const labsService = require('../../../shared/labs');
     const urlUtils = require('../../../shared/url-utils').default;
     const settingsHelpers = require('../settings-helpers');
     const emailAddressParser = require('../email-address/email-address-parser');
@@ -53,6 +52,7 @@ function init(options) {
         getStripeApi: () => require('../stripe').api,
     });
     const giftEmailService = new gift_email_service_1.GiftEmailService({
+        config,
         transactionalMailer: new GhostMailer(),
         bulkMailer: new MailgunClient({ config, settings: settingsCache }),
         settingsCache,
@@ -110,7 +110,6 @@ function init(options) {
         },
         giftReminderScheduler,
         checkoutAdapter,
-        labsService,
         settingsCache,
     });
     exports.service = giftService;

package/core/server/services/i18n.js

@@ -19,7 +19,7 @@ exports.t = (...args) => {
 };
 
 exports.init = () => {
-  const i18n = require('@tryghost/i18n');
+  const i18n = require('@tryghost/i18n').default;
   const events = require('../lib/common/events');
   const settingsCache = require('../../shared/settings-cache');
 

package/core/server/services/identity-tokens/identity-token-service-wrapper.js

@@ -13,12 +13,11 @@ module.exports = class IdentityTokenServiceWrapper {
     const issuer = urlUtils.urlFor('admin', true);
 
     const settings = require('../../../shared/settings-cache');
-    const jose = require('node-jose');
+    const { getPublicKeyInfo } = require('../../lib/public-jwk');
 
     const privateKey = settings.get('ghost_private_key');
-    const keyStore = jose.JWK.createKeyStore();
-    const key = await keyStore.add(privateKey, 'pem');
+    const { kid } = await getPublicKeyInfo(privateKey);
 
-    IdentityTokenServiceWrapper.instance = new IdentityTokenService(privateKey, issuer, key.kid);
+    IdentityTokenServiceWrapper.instance = new IdentityTokenService(privateKey, issuer, kid);
   }
 };

package/core/server/services/jobs-service/index.js

@@ -10,6 +10,14 @@ const errors_1 = __importDefault(require("@tryghost/errors"));
 const jobs_service_1 = require("./jobs-service");
 let instance;
 function init() {
+    // The instance lives for the whole process: the didInit-guarded mentions
+    // service captures it in MentionController and MentionSendingService, so
+    // an in-process restart (test harness) must revive the same object rather
+    // than strand those references on a stopped queue.
+    if (instance) {
+        instance.clearHandlers();
+        return instance;
+    }
     const adapterManager = require('../adapter-manager').default;
     const logging = require('@tryghost/logging');
     const sentry = require('../../../shared/sentry');

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

@@ -11,12 +11,14 @@ class JobsService {
     #logging;
     #sentry;
     #registry = new Map();
+    #queueByType = new Map();
+    #queues = new Map();
     constructor({ backend, logging, sentry }) {
         this.#backend = backend;
         this.#logging = logging;
         this.#sentry = sentry;
     }
-    handle(JobClass, handler) {
+    handle(JobClass, handler, options) {
         const type = JobClass.type;
         if (typeof type !== 'string' || type.length === 0) {
             throw new errors_1.default.IncorrectUsageError({
@@ -28,14 +30,52 @@ class JobsService {
                 message: `A handler for job type "${type}" is already registered.`,
             });
         }
+        this.#declareQueue(type, options);
         this.#registry.set(type, (payload) => handler(new JobClass(JSON.parse(payload))));
     }
+    #declareQueue(type, options) {
+        if (!options) {
+            return;
+        }
+        const { queue, concurrency } = options;
+        if (typeof queue !== 'string' || queue.length === 0) {
+            throw new errors_1.default.IncorrectUsageError({
+                message: `Invalid queue for job type "${type}": ${JSON.stringify(queue)}. Expected a non-empty string.`,
+            });
+        }
+        // "default" is the backend's shared lane for types that declare no queue;
+        // declaring it would silently re-size that lane for every unrouted type.
+        if (queue === 'default') {
+            throw new errors_1.default.IncorrectUsageError({
+                message: `Queue name "default" is reserved for the shared lane; job type "${type}" must omit options to use it.`,
+            });
+        }
+        if (!Number.isInteger(concurrency) || concurrency < 1) {
+            throw new errors_1.default.IncorrectUsageError({
+                message: `Invalid concurrency for job type "${type}": ${JSON.stringify(concurrency)}. Expected a positive integer.`,
+            });
+        }
+        const existing = this.#queues.get(queue);
+        if (existing && existing.concurrency !== concurrency) {
+            throw new errors_1.default.IncorrectUsageError({
+                message: `Conflicting concurrency for queue "${queue}": ${existing.concurrency} is already declared, job type "${type}" declares ${concurrency}.`,
+            });
+        }
+        this.#queues.set(queue, { concurrency });
+        this.#queueByType.set(type, queue);
+    }
+    #routingFor(type) {
+        const queue = this.#queueByType.get(type);
+        return queue === undefined ? undefined : { queue };
+    }
     async dispatch(job) {
-        await this.#backend.enqueue(this.#buildEnvelope(job));
+        const envelope = this.#buildEnvelope(job);
+        await this.#backend.enqueue(envelope, this.#routingFor(envelope.type));
     }
     async scheduleRecurring(job, schedule) {
         this.#assertValidCron(schedule.cron);
-        await this.#backend.scheduleRecurring(this.#buildEnvelope(job), schedule);
+        const envelope = this.#buildEnvelope(job);
+        await this.#backend.scheduleRecurring(envelope, schedule, this.#routingFor(envelope.type));
     }
     // later.parse.cron does not strictly validate: it silently coerces a
     // malformed expression into a bogus schedule (garbage -> every minute,
@@ -55,11 +95,20 @@ class JobsService {
     async start() {
         await this.#backend.start({
             processor: (envelope) => this.#process(envelope),
+            queues: Object.fromEntries(this.#queues),
         });
     }
     async shutdown(options) {
         await this.#backend.shutdown(options);
     }
+    // An in-process restart (test harness) re-runs handler registration on the
+    // same instance, so all registration state resets - handlers and queue
+    // declarations alike. The duplicate-type guard still holds within a boot.
+    clearHandlers() {
+        this.#registry.clear();
+        this.#queueByType.clear();
+        this.#queues.clear();
+    }
     #buildEnvelope(job) {
         return { type: this.#typeOf(job), payload: JSON.stringify(job) };
     }

package/core/server/services/jobs-service/register-job-handlers.js

@@ -45,8 +45,16 @@ const content_csv_import_job_1 = __importDefault(require("../content-import/jobs
 const contentImport = __importStar(require("../content-import"));
 const update_check_job_1 = __importDefault(require("../update-check/jobs/update-check-job"));
 const process_webmention_job_1 = __importDefault(require("../mentions/process-webmention-job"));
+const send_webmentions_job_1 = __importDefault(require("../mentions/send-webmentions-job"));
 const updateCheck = require('../update-check');
-function registerJobHandlers({ jobsService, memberJobs, giftService, mediaInliner, mentionsController, }) {
+// Webmention processing fetches external pages and is triggered by
+// unauthenticated requests, so webmention jobs run in their own lane where a
+// flood cannot occupy the shared workers. The concurrency matches the old
+// dedicated mentions job queue. Every webmention job type must register with
+// this shared declaration so none can declare the queue with a different
+// concurrency.
+const WEBMENTIONS_QUEUE = { queue: 'webmentions', concurrency: 3 };
+function registerJobHandlers({ jobsService, memberJobs, giftService, mediaInliner, mentionsController, mentionsSendingService, }) {
     jobsService.handle(clean_tokens_job_1.default, async () => {
         await memberJobs.cleanTokens();
     });
@@ -67,5 +75,8 @@ function registerJobHandlers({ jobsService, memberJobs, giftService, mediaInline
     });
     jobsService.handle(process_webmention_job_1.default, async (job) => {
         await mentionsController.processWebmention(job);
-    });
+    }, WEBMENTIONS_QUEUE);
+    jobsService.handle(send_webmentions_job_1.default, async (job) => {
+        await mentionsSendingService.sendWebmentions(job);
+    }, WEBMENTIONS_QUEUE);
 }

package/core/server/services/limits.js

@@ -2,7 +2,7 @@ const errors = require('@tryghost/errors');
 const config = require('../../shared/config');
 const db = require('../data/db');
 const logging = require('@tryghost/logging');
-const LimitService = require('@tryghost/limit-service');
+const { LimitService } = require('@tryghost/limit-service');
 let limitService = new LimitService();
 
 const init = () => {
@@ -47,6 +47,22 @@ const init = () => {
   }
 };
 
+/**
+ * Route guard for a feature a host can switch off, for the routes that exist only to
+ * change it. Answers 403 with the host's own wording, which is a different thing to tell a
+ * caller than the 404 a labs flag gives: the feature exists, this plan does not include it.
+ */
+const requireFeature = (limitName) =>
+  async function requireFeatureMw(req, res, next) {
+    try {
+      await limitService.errorIfWouldGoOverLimit(limitName);
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+
 module.exports = limitService;
 
 module.exports.init = init;
+module.exports.requireFeature = requireFeature;

package/core/server/services/member-welcome-emails/service.js

@@ -898,7 +898,7 @@ class MemberWelcomeEmailServiceWrapper {
     }
 
     if (!this.i18n) {
-      const i18nLib = require('@tryghost/i18n');
+      const i18nLib = require('@tryghost/i18n').default;
       const events = require('../../lib/common/events');
 
       this.i18n = i18nLib(settingsCache.get('locale') || 'en', 'ghost');