ghost 5.115.0 → 5.116.0

package/core/server/services/link-redirection/README.md

@@ -0,0 +1,151 @@
+# Link Redirects
+
+
+## Usage
+
+
+## Develop
+
+This is a monorepo package.
+
+Follow the instructions for the top-level repo.
+1. `git clone` this repo & `cd` into it as usual
+2. Run `yarn` to install top-level dependencies.
+
+
+
+## Test
+
+- `yarn lint` run just eslint
+- `yarn test` run lint and tests
+
+## Overview of how Ghost handles LinkRedirects
+### Summary
+When a publisher sends an email newsletter with email click analytics enabled, Ghost will replace all the links in the email's content with a link of the form `https://{site_url}/r/{redirect hash}?m={member UUID}`. When a member clicks on a link in their email, Ghost receives the request, redirects the user to the original link's URL, then updates some analytics data in the database.
+
+### The details
+The following deep-dive covers the link redirect flow from when the member clicks on a link in an email.
+
+First, we lookup the redirect by the `/r/{hash}` value in the URL:
+```
+select `redirects`.* from `redirects` where `redirects`.`from` = ? limit ? undefined
+```
+
+If the redirect exists, the `LinkRedirectsService` emits a `RedirectEvent`, and then responds to the HTTP request with a 302. 
+
+The `LinkClickTrackingService` subscribes to the `RedirectEvent` and kicks off the analytics inserts/updates. First we grab the `uuid` from the `?m={uuid}` parameter and lookup the member by `uuid`:
+```
+select `members`.* from `members` where `members`.`uuid` = ? limit ? undefined
+```
+
+Then we insert a row into the `members_click_events` table to record the click:
+```
+insert into `members_click_events` (`created_at`, `id`, `member_id`, `redirect_id`) values (?, ?, ?, ?) undefined
+```
+
+Then we query for the row we just inserted:
+```
+select `members_click_events`.* from `members_click_events` where `members_click_events`.`id` = ? limit ? undefined
+```
+
+At this point, we emit a `MemberLinkClickEvent` with the member ID and `lastSeenAt` timestamp. 
+
+The `LastSeenAtUpdater` subscribes to the `MemberLinkClickEvent`. First, it checks if the `lastSeenAt` value has already been updated in the current day. 
+
+If it has, we stop here. 
+
+If it hasn't, we continue to update the member. First, we select the member by ID:
+```
+select `members`.* from `members` where `members`.`id` = ? limit ? undefined
+```
+
+Then we start a transaction and get a lock on the member for updating:
+```
+BEGIN; trx34
+select `members`.* from `members` where `members`.`id` = ? limit ? for update trx34
+```
+
+Since we're editing the member, we will eventually need to emit a `member.edited` webhook with the standard includes (labels and newsletters) so we also query them here:
+```
+select `labels`.*, `members_labels`.`member_id` as `_pivot_member_id`, `members_labels`.`label_id` as `_pivot_label_id`, `members_labels`.`sort_order` as `_pivot_sort_order` from `labels` inner join `members_labels` on `members_labels`.`label_id` = `labels`.`id` where `members_labels`.`member_id` in (?) order by `sort_order` ASC for update trx34
+```
+
+Then we query the member's newsletters:
+```
+select `newsletters`.*, `members_newsletters`.`member_id` as `_pivot_member_id`, `members_newsletters`.`newsletter_id` as `_pivot_newsletter_id` from `newsletters` inner join `members_newsletters` on `members_newsletters`.`newsletter_id` = `newsletters`.`id` where `members_newsletters`.`member_id` in (?) order by `newsletters`.`sort_order` ASC for update trx34
+```
+
+Then we update the member:
+```
+update `members` set `uuid` = ?, `transient_id` = ?, `email` = ?, `status` = ?, `name` = ?, `expertise` = ?, `note` = ?, `geolocation` = ?, `enable_comment_notifications` = ?, `email_count` = ?, `email_opened_count` = ?, `email_open_rate` = ?, `email_disabled` = ?, `last_seen_at` = ?, `last_commented_at` = ?, `created_at` = ?, `created_by` = ?, `updated_at` = ?, `updated_by` = ? where `id` = ? trx34
+```
+
+Then we select the member by ID again to get the freshly updated values from the DB:
+```
+select `members`.* from `members` where `members`.`id` = ? limit ? trx34
+```
+
+Then we commit the transaction:
+```
+COMMIT; trx34
+```
+
+Finally, we query for any member.edited webhooks and fire the `member.edited` event:
+```
+select `webhooks`.* from `webhooks` where `event` = ? trx34
+```
+
+
+### Sequence Diagram
+```mermaid
+sequenceDiagram
+    actor Member
+    participant Ghost
+    participant Ghost Async
+    participant DB
+    rect rgba(0,100,0, 0.1)
+    Member ->>Ghost: Clicks link in email
+    Ghost ->> DB: Query: lookup redirect
+    DB ->> Ghost: Redirect record
+    Note right of DB: Serve the redirect
+    Ghost -->> Ghost Async: Emit RedirectEvent
+    Ghost ->> Member: 302 Redirect
+    end
+    rect rgba(100,0,0,0.1)
+    Ghost Async ->> DB: Lookup Member by `uuid` from URL param
+    DB ->> Ghost Async: `member` record
+    Ghost Async ->> DB: Insert `member_click_event`
+    Note right of DB: Insert click event
+    DB ->> Ghost Async: 👌
+    Ghost Async ->> DB: Select `member_click_event`
+    DB ->> Ghost Async: `member_click_event` record
+    end
+    rect rgba(0,0,100, 0.1)
+    Ghost Async ->> DB: Select `member` by id
+    DB ->> Ghost Async: `member` record
+    Ghost Async ->> DB: Begin transaction 
+    activate DB
+    DB ->> Ghost Async: 👌
+    Ghost Async ->> DB: Select `member` for update
+    DB ->> Ghost Async: `member` record
+    Ghost Async ->> DB: Select member labels for update
+    Note right of DB: Update member `lastSeenAt`
+    DB ->> Ghost Async: Member's labels
+    Ghost Async ->> DB: Select member newsletters for update
+    DB ->> Ghost Async: Member's newsletters
+    Ghost Async ->> DB: Update member's `lastSeenAt` timestamp
+    DB ->> Ghost Async: 👌
+    Ghost Async ->> DB: Select `member` by ID
+    DB ->> Ghost Async: `member` record
+    Ghost Async ->> DB: Commit transaction
+    DB ->> Ghost Async: 👌
+    deactivate DB
+    end
+    rect rgba(100,100,0,0.1)
+    Ghost Async ->> DB: Select `webhooks`
+    Note right of DB: Send `member.edited` webhook 
+    DB ->> Ghost Async: `webhook` records
+    create participant Webhook Recipient
+    Ghost Async ->> Webhook Recipient: `member.edited` webhook
+    end
+```

package/core/server/services/link-redirection/RedirectEvent.js

@@ -0,0 +1,24 @@
+/**
+ * @typedef {object} RedirectEventData
+ * @prop {URL} url
+ * @prop {import('./LinkRedirect')} link
+ */
+
+module.exports = class RedirectEvent {
+    /**
+     * @param {RedirectEventData} data
+     * @param {Date} timestamp
+     */
+    constructor(data, timestamp) {
+        this.data = data;
+        this.timestamp = timestamp;
+    }
+
+    /**
+     * @param {RedirectEventData} data
+     * @param {Date} [timestamp]
+     */
+    static create(data, timestamp) {
+        return new RedirectEvent(data, timestamp ?? new Date);
+    }
+};

package/core/server/services/link-redirection/index.js

@@ -14,7 +14,7 @@ class LinkRedirectsServiceWrapper {
         // Wire up all the dependencies
         const models = require('../../models');
 
-        const {LinkRedirectsService} = require('@tryghost/link-redirects');
+        const LinkRedirectsService = require('./LinkRedirectsService');
 
         this.linkRedirectRepository = new LinkRedirectRepository({
             LinkRedirect: models.Redirect,

package/core/server/services/link-tracking/LinkClickTrackingService.js

@@ -1,4 +1,4 @@
-const {RedirectEvent} = require('@tryghost/link-redirects');
+const RedirectEvent = require('../link-redirection/RedirectEvent');
 const LinkClick = require('./ClickEvent');
 const PostLink = require('./PostLink');
 const ObjectID = require('bson-objectid').default;

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

@@ -1,7 +1,7 @@
 const path = require('path');
 const urlUtils = require('../../../shared/url-utils');
 const settingsCache = require('../../../shared/settings-cache');
-const EmailContentGenerator = require('@tryghost/email-content-generator');
+const EmailContentGenerator = require('../lib/EmailContentGenerator');
 
 const emailContentGenerator = new EmailContentGenerator({
     getSiteUrl: () => urlUtils.urlFor('home', true),

package/core/server/services/mail-events/BookshelfMailEventRepository.js

@@ -1,6 +1,6 @@
 /**
- * @typedef {import('@tryghost/mail-events').MailEventRepository} MailEventRepository
- * @typedef {import('@tryghost/mail-events').MailEvent} MailEvent
+ * @typedef {import('./MailEventRepository')} MailEventRepository
+ * @typedef {import('./MailEvent').MailEvent} MailEvent
  */
 
 /**

package/core/server/services/mail-events/InMemoryMailEventRepository.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryMailEventRepository = void 0;
+const InMemoryRepository_1 = require("../lib/InMemoryRepository");
+class InMemoryMailEventRepository extends InMemoryRepository_1.InMemoryRepository {
+    toPrimitive() {
+        return {};
+    }
+}
+exports.InMemoryMailEventRepository = InMemoryMailEventRepository;

package/core/server/services/mail-events/InMemoryMailEventRepository.ts

@@ -0,0 +1,8 @@
+import {InMemoryRepository} from '../lib/InMemoryRepository';
+import {MailEvent} from './MailEvent';
+
+export class InMemoryMailEventRepository extends InMemoryRepository<string, MailEvent> {
+    protected toPrimitive(): object {
+        return {};
+    }
+}

package/core/server/services/mail-events/MailEvent.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MailEvent = void 0;
+class MailEvent {
+    id;
+    type;
+    messageId;
+    recipient;
+    timestampMs;
+    deleted;
+    constructor(id, type, messageId, recipient, timestampMs, deleted = false) {
+        this.id = id;
+        this.type = type;
+        this.messageId = messageId;
+        this.recipient = recipient;
+        this.timestampMs = timestampMs;
+        this.deleted = deleted;
+    }
+}
+exports.MailEvent = MailEvent;

package/core/server/services/mail-events/MailEvent.ts

@@ -0,0 +1,10 @@
+export class MailEvent {
+    constructor(
+        readonly id: string,
+        readonly type: string,
+        readonly messageId: string,
+        readonly recipient: string,
+        readonly timestampMs: number,
+        readonly deleted: boolean = false
+    ) {}
+}

package/core/server/services/mail-events/MailEventRepository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/server/services/mail-events/MailEventRepository.ts

@@ -0,0 +1,5 @@
+import {MailEvent} from './MailEvent';
+
+export interface MailEventRepository {
+    save(event: MailEvent): Promise<void>;
+}

package/core/server/services/mail-events/MailEventService.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MailEventService = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const errors_1 = __importDefault(require("@tryghost/errors"));
+const tpl_1 = __importDefault(require("@tryghost/tpl"));
+const MailEvent_1 = require("./MailEvent");
+/**
+ * @see https://documentation.mailgun.com/en/latest/user_manual.html#events-1
+ */
+var EventType;
+(function (EventType) {
+    EventType["CLICKED"] = "clicked";
+    EventType["COMPLAINED"] = "complained";
+    EventType["DELIVERED"] = "delivered";
+    EventType["FAILED"] = "failed";
+    EventType["OPENED"] = "opened";
+    EventType["UNSUBSCRIBED"] = "unsubscribed";
+})(EventType || (EventType = {}));
+const VALIDATION_MESSAGES = {
+    signingKeyNotConfigured: 'payload signing key is not configured',
+    payloadSignatureMissing: 'Payload is missing "signature"',
+    payloadSignatureInvalid: '"signature" is invalid',
+    payloadEventsMissing: 'Payload is missing "mail_events"',
+    payloadEventsInvalid: '"mail_events" is not an array',
+    payloadEventKeyMissing: 'Event [{idx}] is missing "{key}"'
+};
+class MailEventService {
+    mailEventRepository;
+    config;
+    labs;
+    static LABS_KEY = 'mailEvents';
+    static CONFIG_KEY_PAYLOAD_SIGNING_KEY = 'hostSettings:mailEventsPayloadSigningKey';
+    constructor(mailEventRepository, config, labs) {
+        this.mailEventRepository = mailEventRepository;
+        this.config = config;
+        this.labs = labs;
+    }
+    async processPayload(payload) {
+        if (this.labs.isSet(MailEventService.LABS_KEY) === false) {
+            throw new errors_1.default.NotFoundError();
+        }
+        const payloadSigningKey = this.config.get(MailEventService.CONFIG_KEY_PAYLOAD_SIGNING_KEY);
+        // Verify that the service is configured correctly - We expect a string
+        // for the payload signing key but as a safeguard we check the type here
+        // to prevent any unexpected behaviour
+        if (typeof payloadSigningKey !== 'string') {
+            throw new errors_1.default.InternalServerError({
+                message: (0, tpl_1.default)(VALIDATION_MESSAGES.signingKeyNotConfigured)
+            });
+        }
+        // Verify the payload
+        this.verifyPayload(payload, payloadSigningKey);
+        // Store known events
+        const eventTypes = new Set(Object.values(EventType));
+        for (const payloadEvent of payload.mail_events) {
+            if (eventTypes.has(payloadEvent.event) === false) {
+                continue;
+            }
+            try {
+                await this.mailEventRepository.save(new MailEvent_1.MailEvent(payloadEvent.id, payloadEvent.event, payloadEvent.message.headers['message-id'], payloadEvent.recipient, payloadEvent.timestamp * 1000));
+            }
+            catch (err) {
+                throw new errors_1.default.InternalServerError({
+                    message: 'Event could not be stored',
+                    err: err
+                });
+            }
+        }
+    }
+    validatePayload(payload) {
+        if (payload.signature === undefined) {
+            throw new errors_1.default.ValidationError({
+                message: (0, tpl_1.default)(VALIDATION_MESSAGES.payloadSignatureMissing)
+            });
+        }
+        if (typeof payload.signature !== 'string') {
+            throw new errors_1.default.ValidationError({
+                message: (0, tpl_1.default)(VALIDATION_MESSAGES.payloadSignatureInvalid)
+            });
+        }
+        if (payload.mail_events === undefined) {
+            throw new errors_1.default.ValidationError({
+                message: (0, tpl_1.default)(VALIDATION_MESSAGES.payloadEventsMissing)
+            });
+        }
+        if (Array.isArray(payload.mail_events) === false) {
+            throw new errors_1.default.ValidationError({
+                message: (0, tpl_1.default)(VALIDATION_MESSAGES.payloadEventsInvalid)
+            });
+        }
+        const expectedKeys = ['id', 'timestamp', 'event', 'message', 'recipient'];
+        payload.mail_events.forEach((payloadEvent, idx) => {
+            expectedKeys.forEach((key) => {
+                if (payloadEvent[key] === undefined) {
+                    throw new errors_1.default.ValidationError({
+                        message: (0, tpl_1.default)(VALIDATION_MESSAGES.payloadEventKeyMissing, { idx, key })
+                    });
+                }
+                if (key === 'message' && payloadEvent.message.headers?.['message-id'] === undefined) {
+                    throw new errors_1.default.ValidationError({
+                        message: (0, tpl_1.default)(VALIDATION_MESSAGES.payloadEventKeyMissing, { idx, key: 'message.headers.message-id' })
+                    });
+                }
+            });
+        });
+    }
+    verifyPayload(payload, payloadSigningKey) {
+        const data = JSON.stringify(payload.mail_events);
+        const signature = crypto_1.default
+            .createHmac('sha256', payloadSigningKey)
+            .update(data)
+            .digest('hex');
+        if (signature !== payload.signature) {
+            throw new errors_1.default.UnauthorizedError({
+                message: (0, tpl_1.default)(VALIDATION_MESSAGES.payloadSignatureInvalid)
+            });
+        }
+    }
+}
+exports.MailEventService = MailEventService;

package/core/server/services/mail-events/MailEventService.ts

@@ -0,0 +1,169 @@
+import crypto from 'crypto';
+import errors from '@tryghost/errors';
+import tpl from '@tryghost/tpl';
+
+import {MailEvent} from './MailEvent';
+import {MailEventRepository} from './MailEventRepository';
+
+/**
+ * @see https://documentation.mailgun.com/en/latest/user_manual.html#events-1
+ */
+enum EventType { // eslint-disable-line no-shadow
+    CLICKED = 'clicked',
+    COMPLAINED = 'complained',
+    DELIVERED = 'delivered',
+    FAILED = 'failed',
+    OPENED = 'opened',
+    UNSUBSCRIBED = 'unsubscribed'
+}
+
+interface PayloadEvent {
+    id: string;
+    timestamp: number; // Unix timestamp in seconds
+    event: string;
+    message: {
+        headers: {
+            'message-id': string;
+        }
+    },
+    recipient: string;
+}
+
+interface Payload {
+    signature: string;
+    mail_events: PayloadEvent[];
+}
+
+interface Labs {
+    isSet(key: string): boolean;
+}
+
+interface Config {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get(key: string): any;
+}
+
+const VALIDATION_MESSAGES = {
+    signingKeyNotConfigured: 'payload signing key is not configured',
+    payloadSignatureMissing: 'Payload is missing "signature"',
+    payloadSignatureInvalid: '"signature" is invalid',
+    payloadEventsMissing: 'Payload is missing "mail_events"',
+    payloadEventsInvalid: '"mail_events" is not an array',
+    payloadEventKeyMissing: 'Event [{idx}] is missing "{key}"'
+};
+
+export class MailEventService {
+    static readonly LABS_KEY = 'mailEvents';
+    static readonly CONFIG_KEY_PAYLOAD_SIGNING_KEY = 'hostSettings:mailEventsPayloadSigningKey';
+
+    constructor(
+        private mailEventRepository: MailEventRepository,
+        private config: Config,
+        private labs: Labs
+    ) {}
+
+    async processPayload(payload: Payload) {
+        if (this.labs.isSet(MailEventService.LABS_KEY) === false) {
+            throw new errors.NotFoundError();
+        }
+
+        const payloadSigningKey = this.config.get(MailEventService.CONFIG_KEY_PAYLOAD_SIGNING_KEY);
+
+        // Verify that the service is configured correctly - We expect a string
+        // for the payload signing key but as a safeguard we check the type here
+        // to prevent any unexpected behaviour
+        if (typeof payloadSigningKey !== 'string') {
+            throw new errors.InternalServerError({
+                message: tpl(VALIDATION_MESSAGES.signingKeyNotConfigured)
+            });
+        }
+
+        // Verify the payload
+        this.verifyPayload(payload, payloadSigningKey);
+
+        // Store known events
+        const eventTypes = new Set<string>(Object.values(EventType) as string[]);
+
+        for (const payloadEvent of payload.mail_events) {
+            if (eventTypes.has(payloadEvent.event) === false) {
+                continue;
+            }
+
+            try {
+                await this.mailEventRepository.save(
+                    new MailEvent(
+                        payloadEvent.id,
+                        payloadEvent.event,
+                        payloadEvent.message.headers['message-id'],
+                        payloadEvent.recipient,
+                        payloadEvent.timestamp * 1000
+                    )
+                );
+            } catch (err) {
+                throw new errors.InternalServerError({
+                    message: 'Event could not be stored',
+                    err: err
+                });
+            }
+        }
+    }
+
+    validatePayload(payload: Payload) {
+        if (payload.signature === undefined) {
+            throw new errors.ValidationError({
+                message: tpl(VALIDATION_MESSAGES.payloadSignatureMissing)
+            });
+        }
+
+        if (typeof payload.signature !== 'string') {
+            throw new errors.ValidationError({
+                message: tpl(VALIDATION_MESSAGES.payloadSignatureInvalid)
+            });
+        }
+
+        if (payload.mail_events === undefined) {
+            throw new errors.ValidationError({
+                message: tpl(VALIDATION_MESSAGES.payloadEventsMissing)
+            });
+        }
+
+        if (Array.isArray(payload.mail_events) === false) {
+            throw new errors.ValidationError({
+                message: tpl(VALIDATION_MESSAGES.payloadEventsInvalid)
+            });
+        }
+
+        const expectedKeys: (keyof PayloadEvent)[] = ['id', 'timestamp', 'event', 'message', 'recipient'];
+
+        payload.mail_events.forEach((payloadEvent, idx) => {
+            expectedKeys.forEach((key) => {
+                if (payloadEvent[key] === undefined) {
+                    throw new errors.ValidationError({
+                        message: tpl(VALIDATION_MESSAGES.payloadEventKeyMissing, {idx, key})
+                    });
+                }
+
+                if (key === 'message' && payloadEvent.message.headers?.['message-id'] === undefined) {
+                    throw new errors.ValidationError({
+                        message: tpl(VALIDATION_MESSAGES.payloadEventKeyMissing, {idx, key: 'message.headers.message-id'})
+                    });
+                }
+            });
+        });
+    }
+
+    private verifyPayload(payload: Payload, payloadSigningKey: string) {
+        const data = JSON.stringify(payload.mail_events);
+
+        const signature = crypto
+            .createHmac('sha256', payloadSigningKey)
+            .update(data)
+            .digest('hex');
+
+        if (signature !== payload.signature) {
+            throw new errors.UnauthorizedError({
+                message: tpl(VALIDATION_MESSAGES.payloadSignatureInvalid)
+            });
+        }
+    }
+}

package/core/server/services/mail-events/index.js

@@ -1,4 +1,4 @@
-const {MailEventService} = require('@tryghost/mail-events');
+const {MailEventService} = require('./MailEventService');
 const MailEventRepository = require('./BookshelfMailEventRepository.js');
 
 class MailEventsServiceWrapper {

package/core/server/services/mail-events/libraries.d.ts

@@ -0,0 +1,2 @@
+declare module '@tryghost/errors';
+declare module '@tryghost/tpl';

package/core/server/services/members/CaptchaService.js

@@ -0,0 +1,80 @@
+const hcaptcha = require('hcaptcha');
+const logging = require('@tryghost/logging');
+const {InternalServerError, BadRequestError, utils: errorUtils} = require('@tryghost/errors');
+
+class CaptchaService {
+    #enabled;
+    #scoreThreshold;
+    #secretKey;
+
+    /**
+     * @param {Object} options
+     * @param {boolean} [options.enabled] Whether hCaptcha is enabled
+     * @param {number} [options.scoreThreshold] Score threshold for bot detection
+     * @param {string} [options.secretKey] hCaptcha secret key
+     */
+    constructor({
+        enabled,
+        scoreThreshold,
+        secretKey
+    }) {
+        this.#enabled = enabled;
+        this.#secretKey = secretKey;
+        this.#scoreThreshold = scoreThreshold;
+    }
+
+    getMiddleware() {
+        const scoreThreshold = this.#scoreThreshold;
+        const secretKey = this.#secretKey;
+
+        if (!this.#enabled) {
+            return function captchaNoOpMiddleware(req, res, next) {
+                next();
+            };
+        }
+
+        return async function captchaMiddleware(req, res, next) {
+            let captchaResponse;
+
+            try {
+                if (!req.body || !req.body.token) {
+                    throw new BadRequestError({
+                        message: 'hCaptcha token missing'
+                    });
+                }
+
+                captchaResponse = await hcaptcha.verify(secretKey, req.body.token, req.ip);
+
+                if ('score' in captchaResponse && captchaResponse.score < scoreThreshold) {
+                    // Using hCaptcha enterprise, so score is present
+                    next();
+                } else if (!('score' in captchaResponse) && captchaResponse.success) {
+                    // Using regular hCaptcha, so challenge-based
+                    next();
+                } else {
+                    logging.error(`Blocking request due to high score (${captchaResponse.score})`);
+
+                    // Intentionally left sparse to avoid leaking information
+                    throw new InternalServerError();
+                }
+            } catch (err) {
+                if (errorUtils.isGhostError(err)) {
+                    return next(err);
+                } else {
+                    const message = 'Failed to verify hCaptcha token';
+
+                    logging.error(new InternalServerError({
+                        message,
+                        err
+                    }));
+
+                    return next(new InternalServerError({
+                        message
+                    }));
+                }
+            }
+        };
+    }
+}
+
+module.exports = CaptchaService;

package/core/server/services/members/api.js

@@ -18,7 +18,7 @@ const tiersService = require('../tiers');
 const newslettersService = require('../newsletters');
 const memberAttributionService = require('../member-attribution');
 const emailSuppressionList = require('../email-suppression-list');
-const CaptchaService = require('@tryghost/captcha-service');
+const CaptchaService = require('./CaptchaService');
 const {t} = require('../i18n');
 const sentry = require('../../../shared/sentry');
 const sharedConfig = require('../../../shared/config');