ghost 5.61.3 → 5.62.0

package/core/built/admin/index.html

@@ -8,7 +8,7 @@
     <title>Ghost Admin</title>
 
     
-<meta name="ghost-admin/config/environment" content="%7B%22modulePrefix%22%3A%22ghost-admin%22%2C%22environment%22%3A%22production%22%2C%22cdnUrl%22%3A%22%22%2C%22rootURL%22%3A%22%22%2C%22locationType%22%3A%22trailing-hash%22%2C%22EmberENV%22%3A%7B%22FEATURES%22%3A%7B%7D%2C%22EXTEND_PROTOTYPES%22%3A%7B%22Date%22%3Afalse%2C%22Array%22%3Atrue%2C%22String%22%3Atrue%2C%22Function%22%3Afalse%7D%2C%22_APPLICATION_TEMPLATE_WRAPPER%22%3Afalse%2C%22_JQUERY_INTEGRATION%22%3Atrue%2C%22_TEMPLATE_ONLY_GLIMMER_COMPONENTS%22%3Atrue%7D%2C%22APP%22%3A%7B%22version%22%3A%225.61%22%2C%22name%22%3A%22ghost-admin%22%7D%2C%22ember-simple-auth%22%3A%7B%7D%2C%22ember-websockets%22%3A%7B%22socketIO%22%3Atrue%7D%2C%22%40sentry%2Fember%22%3A%7B%22disablePerformance%22%3Atrue%2C%22sentry%22%3A%7B%7D%7D%2C%22ember-cli-mirage%22%3A%7B%22usingProxy%22%3Afalse%2C%22useDefaultPassthroughs%22%3Atrue%7D%2C%22exportApplicationGlobal%22%3Afalse%2C%22ember-load%22%3A%7B%22loadingIndicatorClass%22%3A%22ember-load-indicator%22%7D%7D" />
+<meta name="ghost-admin/config/environment" content="%7B%22modulePrefix%22%3A%22ghost-admin%22%2C%22environment%22%3A%22production%22%2C%22cdnUrl%22%3A%22%22%2C%22rootURL%22%3A%22%22%2C%22locationType%22%3A%22trailing-hash%22%2C%22EmberENV%22%3A%7B%22FEATURES%22%3A%7B%7D%2C%22EXTEND_PROTOTYPES%22%3A%7B%22Date%22%3Afalse%2C%22Array%22%3Atrue%2C%22String%22%3Atrue%2C%22Function%22%3Afalse%7D%2C%22_APPLICATION_TEMPLATE_WRAPPER%22%3Afalse%2C%22_JQUERY_INTEGRATION%22%3Atrue%2C%22_TEMPLATE_ONLY_GLIMMER_COMPONENTS%22%3Atrue%7D%2C%22APP%22%3A%7B%22version%22%3A%225.62%22%2C%22name%22%3A%22ghost-admin%22%7D%2C%22ember-simple-auth%22%3A%7B%7D%2C%22ember-websockets%22%3A%7B%22socketIO%22%3Atrue%7D%2C%22%40sentry%2Fember%22%3A%7B%22disablePerformance%22%3Atrue%2C%22sentry%22%3A%7B%7D%7D%2C%22ember-cli-mirage%22%3A%7B%22usingProxy%22%3Afalse%2C%22useDefaultPassthroughs%22%3Atrue%7D%2C%22exportApplicationGlobal%22%3Afalse%2C%22ember-load%22%3A%7B%22loadingIndicatorClass%22%3A%22ember-load-indicator%22%7D%7D" />
 
     <meta name="HandheldFriendly" content="True" />
     <meta name="MobileOptimized" content="320" />
@@ -56,9 +56,9 @@
 
     <div id="ember-basic-dropdown-wormhole"></div>
 
-    <script src="assets/vendor-3631184082d609038638c1e169a002e7.js"></script>
-<script src="assets/chunk.208.dbf172ad32f72f21a5dc.js"></script>
-<script src="assets/chunk.143.da84b3b434141aff0f01.js"></script>
-    <script src="assets/ghost-54f84395df6a6fb47b37008ded8eba22.js"></script>
+    <script src="assets/vendor-b50a3e5c2079b8a35d9122a1a4c34ef6.js"></script>
+<script src="assets/chunk.853.f743ed975e8838475532.js"></script>
+<script src="assets/chunk.143.5b5502a550ce35005d0f.js"></script>
+    <script src="assets/ghost-d804aba7bca07fa75d308ab892c508fc.js"></script>
 </body>
 </html>

package/core/server/adapters/storage/LocalStorageBase.js

@@ -4,9 +4,7 @@ const serveStatic = require('../../../shared/express').static;
 
 const fs = require('fs-extra');
 const path = require('path');
-const moment = require('moment');
 const tpl = require('@tryghost/tpl');
-const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
 const constants = require('@tryghost/constants');
 const urlUtils = require('../../../shared/url-utils');
@@ -127,16 +125,11 @@ class LocalStorageBase extends StorageBase {
         const {storagePath, errorMessages} = this;
 
         return function serveStaticContent(req, res, next) {
-            const startedAtMoment = moment();
-
             return serveStatic(
                 storagePath,
                 {
                     maxAge: constants.ONE_YEAR_MS,
-                    fallthrough: false,
-                    onEnd: () => {
-                        logging.info('LocalStorageBase.serve', req.path, moment().diff(startedAtMoment, 'ms') + 'ms');
-                    }
+                    fallthrough: false
                 }
             )(req, res, (err) => {
                 if (err) {

package/core/server/api/endpoints/recommendations-public.js

@@ -9,16 +9,13 @@ module.exports = {
         },
         options: [
             'limit',
-            'fields',
-            'filter',
             'order',
-            'debug',
             'page'
         ],
         permissions: true,
         validation: {},
-        async query() {
-            return await recommendations.controller.listRecommendations();
+        async query(frame) {
+            return await recommendations.controller.listRecommendations(frame);
         }
     }
 };

package/core/server/api/endpoints/recommendations.js

@@ -7,11 +7,14 @@ module.exports = {
         headers: {
             cacheInvalidate: false
         },
-        options: [],
+        options: [
+            'limit',
+            'page'
+        ],
         permissions: true,
         validation: {},
-        async query() {
-            return await recommendations.controller.listRecommendations();
+        async query(frame) {
+            return await recommendations.controller.listRecommendations(frame);
         }
     },
 

package/core/server/api/endpoints/utils/serializers/input/pages.js

@@ -6,6 +6,8 @@ const slugFilterOrder = require('./utils/slug-filter-order');
 const localUtils = require('../../index');
 const postsMetaSchema = require('../../../../../data/schema').tables.posts_meta;
 const clean = require('./utils/clean');
+const labs = require('../../../../../../shared/labs');
+const lexical = require('../../../../../lib/lexical');
 
 function removeSourceFormats(frame) {
     if (frame.options.formats?.includes('mobiledoc') || frame.options.formats?.includes('lexical')) {
@@ -133,6 +135,12 @@ module.exports = {
 
             if (frame.options.source === 'html' && !_.isEmpty(html)) {
                 frame.data.pages[0].mobiledoc = JSON.stringify(mobiledoc.htmlToMobiledocConverter(html));
+
+                // normally we don't allow both mobiledoc+lexical but the model layer will remove lexical
+                // if mobiledoc is already present to avoid migrating formats outside of an explicit conversion
+                if (labs.isSet('lexicalEditor')) {
+                    frame.data.pages[0].lexical = JSON.stringify(lexical.htmlToLexicalConverter(html));
+                }
             }
         }
 

package/core/server/api/endpoints/utils/serializers/input/posts.js

@@ -6,6 +6,8 @@ const localUtils = require('../../index');
 const mobiledoc = require('../../../../../lib/mobiledoc');
 const postsMetaSchema = require('../../../../../data/schema').tables.posts_meta;
 const clean = require('./utils/clean');
+const labs = require('../../../../../../shared/labs');
+const lexical = require('../../../../../lib/lexical');
 
 function removeSourceFormats(frame) {
     if (frame.options.formats?.includes('mobiledoc') || frame.options.formats?.includes('lexical')) {
@@ -32,7 +34,7 @@ function defaultRelations(frame) {
     // Apply same mapping as content API
     mapWithRelated(frame);
 
-    // Addditional defaults for admin API
+    // Additional defaults for admin API
     if (frame.options.withRelated) {
         return;
     }
@@ -167,6 +169,12 @@ module.exports = {
 
             if (frame.options.source === 'html' && !_.isEmpty(html)) {
                 frame.data.posts[0].mobiledoc = JSON.stringify(mobiledoc.htmlToMobiledocConverter(html));
+
+                // normally we don't allow both mobiledoc+lexical but the model layer will remove lexical
+                // if mobiledoc is already present to avoid migrating formats outside of an explicit conversion
+                if (labs.isSet('lexicalEditor')) {
+                    frame.data.posts[0].lexical = JSON.stringify(lexical.htmlToLexicalConverter(html));
+                }
             }
         }
 

package/core/server/api/endpoints/utils/serializers/output/site.js

@@ -11,10 +11,12 @@ module.exports = {
                 'description',
                 'logo',
                 'icon',
+                'cover_image',
                 'accent_color',
                 'locale',
                 'url',
                 'version',
+                'allow_self_signup',
                 'sentry_dsn',
                 'sentry_env'
             ])

package/core/server/lib/lexical.js

@@ -1,4 +1,5 @@
 const path = require('path');
+const errors = require('@tryghost/errors');
 const urlUtils = require('../../shared/url-utils');
 const config = require('../../shared/config');
 const storage = require('../adapters/storage');
@@ -78,5 +79,19 @@ module.exports = {
         }
 
         return urlTransformMap;
+    },
+
+    get htmlToLexicalConverter() {
+        try {
+            return require('@tryghost/kg-html-to-lexical').htmlToLexical;
+        } catch (err) {
+            throw new errors.InternalServerError({
+                message: 'Unable to convert from source HTML to Lexical',
+                context: 'The html-to-lexical package was not installed',
+                help: 'Please review any errors from the install process by checking the Ghost logs',
+                code: 'HTML_TO_LEXICAL_INSTALLATION',
+                err: err
+            });
+        }
     }
 };

package/core/server/models/base/plugins/crud.js

@@ -44,6 +44,12 @@ module.exports = function (Bookshelf) {
                 });
             }
 
+            if (options.page && options.limit) {
+                itemCollection
+                    .query('limit', options.limit)
+                    .query('offset', options.limit * (options.page - 1));
+            }
+
             const result = await itemCollection.fetchAll(options);
             if (options.withRelated) {
                 _.each(result.models, function each(item) {

package/core/server/models/base/plugins/sanitize.js

@@ -45,7 +45,7 @@ module.exports = function (Bookshelf) {
             case 'findOne':
                 return baseOptions.concat(extraOptions, ['columns', 'require', 'mongoTransformer']);
             case 'findAll':
-                return baseOptions.concat(extraOptions, ['filter', 'columns', 'mongoTransformer']);
+                return baseOptions.concat(extraOptions, ['filter', 'columns', 'mongoTransformer', 'page', 'limit']);
             case 'findPage':
                 return baseOptions.concat(extraOptions, ['filter', 'order', 'autoOrder', 'page', 'limit', 'columns', 'mongoTransformer']);
             default:

package/core/server/models/post.js

@@ -552,6 +552,16 @@ Post = ghostBookshelf.Model.extend({
         let tagsToSave;
         const ops = [];
 
+        // normally we don't allow both mobiledoc & lexical through at the API level but there's
+        // an exception for ?source=html which always sets both when the lexical editor is enabled.
+        // That's necessary because at the input serializer layer we don't have access to the
+        // actual model to check if this would result in a change of format
+        if (this.previous('mobiledoc') && this.get('lexical')) {
+            this.set('lexical', null);
+        } else if (this.get('mobiledoc') && this.get('lexical')) {
+            this.set('mobiledoc', null);
+        }
+
         // CASE: disallow published -> scheduled
         // @TODO: remove when we have versioning based on updated_at
         if (newStatus !== olderStatus && newStatus === 'scheduled' && olderStatus === 'published') {
@@ -653,7 +663,7 @@ Post = ghostBookshelf.Model.extend({
 
         // If we're force re-rendering we want to make sure that all image cards
         // have original dimensions stored in the payload for use by card renderers
-        if (options.force_rerender) {
+        if (options.force_rerender && this.get('mobiledoc')) {
             this.set('mobiledoc', await mobiledocLib.populateImageSizes(this.get('mobiledoc')));
         }
 

package/core/server/services/mentions/WebmentionMetadata.js

@@ -1,12 +1,41 @@
 const oembedService = require('../oembed');
 
 module.exports = class WebmentionMetadata {
+    /**
+     * Helpers that change the URL for which metadata for a given external resource is fetched. Return undefined to now handle the URL.
+     * @type {((url: URL) => URL|undefined)[]}
+     */
+    #mappers = [];
+
+    /**
+     * @param {(url: URL) => URL|undefined} mapper
+     */
+    addMapper(mapper) {
+        this.#mappers.push(mapper);
+    }
+
+    /**
+     *
+     * @param {URL} url
+     */
+    #getMappedUrl(url) {
+        for (const mapper of this.#mappers) {
+            const mappedUrl = mapper(url);
+            if (mappedUrl) {
+                return this.#getMappedUrl(mappedUrl);
+            }
+        }
+        return url;
+    }
+
     /**
      * @param {URL} url
      * @returns {Promise<import('@tryghost/webmentions/lib/MentionsAPI').WebmentionMetadata>}
      */
     async fetch(url) {
-        const data = await oembedService.fetchOembedDataFromUrl(url.href, 'mention');
+        const mappedUrl = this.#getMappedUrl(url);
+        const data = await oembedService.fetchOembedDataFromUrl(mappedUrl.href, 'mention');
+
         const result = {
             siteTitle: data.metadata.publisher,
             title: data.metadata.title,
@@ -17,6 +46,14 @@ module.exports = class WebmentionMetadata {
             body: data.body,
             contentType: data.contentType
         };
+
+        if (mappedUrl.href !== url.href) {
+            // Still need to fetch body and contentType separately now
+            // For verification
+            const {body, contentType} = await oembedService.fetchPageHtml(url);
+            result.body = body;
+            result.contentType = contentType;
+        }
         return result;
     }
 };

package/core/server/services/mentions/service.js

@@ -28,6 +28,7 @@ module.exports = {
     /** @type {import('@tryghost/webmentions/lib/MentionsAPI')} */
     api: null,
     controller: new MentionController(),
+    metadata: new WebmentionMetadata(),
     /** @type {import('@tryghost/webmentions/lib/MentionSendingService')} */
     sendingService: null,
     didInit: false,
@@ -40,7 +41,7 @@ module.exports = {
             MentionModel: models.Mention,
             DomainEvents
         });
-        const webmentionMetadata = new WebmentionMetadata();
+        const webmentionMetadata = this.metadata;
         const discoveryService = new MentionDiscoveryService({externalRequest});
         const resourceService = new ResourceService({
             urlUtils,

package/core/server/services/offers/OfferBookshelfRepository.js

@@ -0,0 +1,230 @@
+const {flowRight} = require('lodash');
+const {mapKeyValues, mapQuery} = require('@tryghost/mongo-utils');
+const DomainEvents = require('@tryghost/domain-events');
+const {Offer} = require('@tryghost/members-offers');
+const sentry = require('../../../shared/sentry');
+const logger = require('@tryghost/logging');
+
+const statusTransformer = mapKeyValues({
+    key: {
+        from: 'status',
+        to: 'active'
+    },
+    values: [{
+        from: 'active',
+        to: true
+    }, {
+        from: 'archived',
+        to: false
+    }]
+});
+
+const rejectNonStatusTransformer = input => mapQuery(input, function (value, key) {
+    if (key !== 'status') {
+        return;
+    }
+
+    return {
+        [key]: value
+    };
+});
+
+const mongoTransformer = flowRight(statusTransformer, rejectNonStatusTransformer);
+
+/**
+ * @typedef {object} BaseOptions
+ * @prop {import('knex').Transaction} transacting
+ */
+
+/**
+ * @typedef {object} ListOptions
+ * @prop {import('knex').Transaction} transacting
+ * @prop {string} filter
+ */
+
+class OfferBookshelfRepository {
+    /**
+     * @param {{forge: (data: object) => import('bookshelf').Model<Offer.OfferProps>}} OfferModel
+     * @param {{forge: (data: object) => import('bookshelf').Model<any>}} OfferRedemptionModel
+     */
+    constructor(OfferModel, OfferRedemptionModel) {
+        /** @private */
+        this.OfferModel = OfferModel;
+        /** @private */
+        this.OfferRedemptionModel = OfferRedemptionModel;
+    }
+
+    /**
+     * @template T
+     * @param {(t: import('knex').Transaction) => Promise<T>} cb
+     * @returns {Promise<T>}
+     */
+    async createTransaction(cb) {
+        return this.OfferModel.transaction(cb);
+    }
+
+    /**
+     * @param {string} name
+     * @param {BaseOptions} [options]
+     * @returns {Promise<boolean>}
+     */
+    async existsByName(name, options) {
+        const model = await this.OfferModel.findOne({name}, options);
+        if (!model) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @param {string} code
+     * @param {BaseOptions} [options]
+     * @returns {Promise<boolean>}
+     */
+    async existsByCode(code, options) {
+        const model = await this.OfferModel.findOne({code}, options);
+        if (!model) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @private
+     * @param {import('bookshelf').Model<any>} model
+     * @param {BaseOptions} options
+     * @returns {Promise<import('@tryghost/members-offers').Offer>}
+     */
+    async mapToOffer(model, options) {
+        const json = model.toJSON();
+
+        const count = await this.OfferRedemptionModel.where({offer_id: json.id}).count('id', {
+            transacting: options.transacting
+        });
+        try {
+            return await Offer.create({
+                id: json.id,
+                name: json.name,
+                code: json.code,
+                display_title: json.portal_title,
+                display_description: json.portal_description,
+                type: json.discount_type === 'amount' ? 'fixed' : json.discount_type,
+                amount: json.discount_amount,
+                cadence: json.interval,
+                currency: json.currency,
+                duration: json.duration,
+                duration_in_months: json.duration_in_months,
+                redemptionCount: count,
+                status: json.active ? 'active' : 'archived',
+                tier: {
+                    id: json.product.id,
+                    name: json.product.name
+                }
+            }, null);
+        } catch (err) {
+            logger.error(err);
+            sentry.captureException(err);
+            return null;
+        }
+    }
+
+    /**
+     * @param {string} id
+     * @param {BaseOptions} [options]
+     * @returns {Promise<import('@tryghost/members-offers').Offer>}
+     */
+    async getById(id, options) {
+        const model = await this.OfferModel.findOne({id}, {
+            ...options,
+            withRelated: ['product']
+        });
+
+        if (!model) {
+            return null;
+        }
+
+        return this.mapToOffer(model, options);
+    }
+
+    /**
+     * @param {string} id stripe_coupon_id
+     * @param {BaseOptions} [options]
+     * @returns {Promise<import('@tryghost/members-offers').Offer>}
+     */
+    async getByStripeCouponId(id, options) {
+        const model = await this.OfferModel.findOne({stripe_coupon_id: id}, {
+            ...options,
+            withRelated: ['product']
+        });
+
+        if (!model) {
+            return null;
+        }
+
+        return this.mapToOffer(model, options);
+    }
+
+    /**
+     * @param {ListOptions} options
+     * @returns {Promise<import('@tryghost/members-offers').Offer[]>}
+     */
+    async getAll(options) {
+        const models = await this.OfferModel.findAll({
+            ...options,
+            mongoTransformer,
+            withRelated: ['product']
+        });
+
+        const mapOptions = {
+            transacting: options && options.transacting
+        };
+
+        const offers = models.map(model => this.mapToOffer(model, mapOptions));
+
+        return (await Promise.all(offers)).filter(offer => offer !== null);
+    }
+
+    /**
+     * @param {import('@tryghost/members-offers').Offer} offer
+     * @param {BaseOptions} [options]
+     * @returns {Promise<void>}
+     */
+    async save(offer, options) {
+        /** @type any */
+        const data = {
+            id: offer.id,
+            name: offer.name.value,
+            code: offer.code.value,
+            portal_title: offer.displayTitle.value || null,
+            portal_description: offer.displayDescription.value || null,
+            discount_type: offer.type.value === 'fixed' ? 'amount' : offer.type.value,
+            discount_amount: offer.amount.value,
+            interval: offer.cadence.value,
+            product_id: offer.tier.id,
+            duration: offer.duration.value.type,
+            duration_in_months: offer.duration.value.type === 'repeating' ? offer.duration.value.months : null,
+            currency: offer.currency ? offer.currency.value : null,
+            active: offer.status.value === 'active'
+        };
+
+        if (offer.isNew) {
+            await this.OfferModel.add(data, options);
+        } else {
+            await this.OfferModel.edit(data, {...options, id: data.id});
+        }
+
+        for (const event of offer.events) {
+            if (options.transacting) {
+                // Only dispatch the event after the transaction has finished
+                // Because else the offer won't be committed to the database yet
+                options.transacting.executionPromise.then(() => {
+                    DomainEvents.dispatch(event);
+                });
+            } else {
+                DomainEvents.dispatch(event);
+            }
+        }
+    }
+}
+
+module.exports = OfferBookshelfRepository;

package/core/server/services/offers/service.js

@@ -4,6 +4,7 @@ const OffersModule = require('@tryghost/members-offers');
 const config = require('../../../shared/config');
 const urlUtils = require('../../../shared/url-utils');
 const models = require('../../models');
+const OfferBookshelfRepository = require('./OfferBookshelfRepository');
 
 let redirectManager;
 
@@ -15,10 +16,13 @@ module.exports = {
                 return urlUtils.urlJoin(urlUtils.getSubdir(), pathname);
             }
         });
+        const repository = new OfferBookshelfRepository(
+            models.Offer,
+            models.OfferRedemption
+        );
         const offersModule = OffersModule.create({
-            OfferModel: models.Offer,
-            OfferRedemptionModel: models.OfferRedemption,
-            redirectManager
+            redirectManager,
+            repository
         });
 
         this.api = offersModule.api;

package/core/server/services/public-config/site.js

@@ -9,10 +9,12 @@ module.exports = function getSiteProperties() {
         description: settingsCache.get('description'),
         logo: settingsCache.get('logo'),
         icon: settingsCache.get('icon'),
+        cover_image: settingsCache.get('cover_image'),
         accent_color: settingsCache.get('accent_color'),
         locale: settingsCache.get('locale'),
         url: urlUtils.urlFor('home', true),
-        version: ghostVersion.safe
+        version: ghostVersion.safe,
+        allow_self_signup: settingsCache.get('allow_self_signup')
     };
 
     if (config.get('client_sentry') && !config.get('client_sentry').disabled) {

package/core/server/services/recommendations/RecommendationEnablerService.js

@@ -0,0 +1,28 @@
+module.exports = class RecommendationEnablerService {
+    /** @type {import('../settings/SettingsBREADService')} */
+    #settingsService;
+
+    /**
+     * @param {object} deps
+     * @param {import('../settings/SettingsBREADService')} deps.settingsService
+     */
+    constructor(deps) {
+        this.#settingsService = deps.settingsService;
+    }
+
+    /**
+     * @returns {string}
+     */
+    getSetting() {
+        this.#settingsService.read('recommendations_enabled');
+    }
+
+    /**
+     *
+     * @param {string} value
+     * @returns Promise<void>
+     */
+    async setSetting(value) {
+        this.#settingsService.edit([{key: 'recommendations_enabled', value}], {context: {internal: true}});
+    }
+};

package/core/server/services/recommendations/RecommendationServiceWrapper.js

@@ -23,7 +23,14 @@ class RecommendationServiceWrapper {
         const urlUtils = require('../../../shared/url-utils');
         const models = require('../../models');
         const sentry = require('../../../shared/sentry');
-        const {BookshelfRecommendationRepository, RecommendationService, RecommendationController, WellknownService} = require('@tryghost/recommendations');
+        const settings = require('../settings');
+        const RecommendationEnablerService = require('./RecommendationEnablerService');
+        const {
+            BookshelfRecommendationRepository,
+            RecommendationService,
+            RecommendationController,
+            WellknownService
+        } = require('@tryghost/recommendations');
 
         const mentions = require('../mentions');
 
@@ -37,11 +44,15 @@ class RecommendationServiceWrapper {
             urlUtils
         });
 
+        const settingsService = settings.getSettingsBREADServiceInstance();
+        const recommendationEnablerService = new RecommendationEnablerService({settingsService});
+
         this.repository = new BookshelfRecommendationRepository(models.Recommendation, {
             sentry
         });
         this.service = new RecommendationService({
             repository: this.repository,
+            recommendationEnablerService,
             wellknownService,
             mentionSendingService: mentions.sendingService
         });
@@ -51,6 +62,17 @@ class RecommendationServiceWrapper {
 
         // eslint-disable-next-line no-console
         this.service.init().catch(console.error);
+
+        // Add mapper to WebmentionMetadata
+        mentions.metadata.addMapper((url) => {
+            const p = '/.well-known/recommendations.json';
+            if (url.pathname.endsWith(p)) {
+                // Strip p
+                const newUrl = new URL(url.toString());
+                newUrl.pathname = newUrl.pathname.slice(0, -p.length);
+                return newUrl;
+            }
+        });
     }
 }
 

package/core/server/services/settings/SettingsBREADService.js

@@ -147,7 +147,7 @@ class SettingsBREADService {
      * @param {Object[]} settings
      * @param {Object} options
      * @param {Object} [options.context]
-     * @param {Object} [stripeConnectData]
+     * @param {Object|null} [stripeConnectData]
      * @returns
      */
     async edit(settings, options, stripeConnectData) {