ghost 5.36.1 → 5.37.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%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.36%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%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.37%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" />
@@ -37,7 +37,7 @@
     </style>
 
     <link integrity="" rel="stylesheet" href="assets/vendor-3e6947aa681f0fb82b193090e520dc73.css">
-    <link integrity="" rel="stylesheet" href="assets/ghost-7ecf5c7934d90798485ee5ac2956f7fe.css" title="light">
+    <link integrity="" rel="stylesheet" href="assets/ghost-efbe4dcc249d119a955b038aae5c980d.css" title="light">
 
     
 </head>
@@ -56,9 +56,9 @@
 
     <div id="ember-basic-dropdown-wormhole"></div>
 
-    <script src="assets/vendor-c4684647d4f5213e5dbb6763de430e7e.js"></script>
-<script src="assets/chunk.502.800e1515996bcc900013.js"></script>
-<script src="assets/chunk.143.26ea9f26571d656653f0.js"></script>
-    <script src="assets/ghost-b828e9e3c161aae92909c2e163656bb1.js"></script>
+    <script src="assets/vendor-b982e3bf1020bff77b2a3c44d5f59e55.js"></script>
+<script src="assets/chunk.652.bb618bc5abf23bed4e87.js"></script>
+<script src="assets/chunk.143.27cd10a38f877e715b35.js"></script>
+    <script src="assets/ghost-2948791640be026b987b88f89034bc85.js"></script>
 </body>
 </html>

package/core/frontend/apps/amp/lib/helpers/amp_content.js

@@ -6,7 +6,7 @@
 //
 // Converts normal HTML into AMP HTML with Amperize module and uses a cache to return it from
 // there if available. The cacheId is a combination of `updated_at` and the `slug`.
-const {DateTime, Interval} = require('luxon');
+const {DateTime} = require('luxon');
 const errors = require('@tryghost/errors');
 const logging = require('@tryghost/logging');
 
@@ -120,8 +120,6 @@ function getAmperizeHTML(html, post) {
 
     amperize = amperize || new Amperize();
 
-    const startedAtMoment = DateTime.now();
-
     let cacheDateTime;
     let postDateTime;
 
@@ -136,8 +134,6 @@ function getAmperizeHTML(html, post) {
     if (!amperizeCache[post.id] || cacheDateTime.diff(postDateTime).valueOf() < 0) {
         return new Promise((resolve) => {
             amperize.parse(html, (err, res) => {
-                logging.info('amp.parse', post.url, Interval.fromDateTimes(startedAtMoment, DateTime.now()).length('milliseconds') + 'ms');
-
                 if (err) {
                     if (err.src) {
                         // This is a valid 500 GhostError because it means the amperize parser is unable to handle some Ghost HTML.

package/core/frontend/meta/asset-url.js

@@ -2,6 +2,7 @@ const crypto = require('crypto');
 const config = require('../../shared/config');
 const {blogIcon} = require('../../server/lib/image');
 const urlUtils = require('../../shared/url-utils');
+const {SafeString} = require('../services/handlebars');
 
 /**
  * Serve either uploaded favicon or default
@@ -11,7 +12,15 @@ function getFaviconUrl() {
     return blogIcon.getIconUrl();
 }
 
+/**
+ * Prepare URL for an asset
+ * @param {string|SafeString} path — the asset’s path
+ * @param {boolean} hasMinFile — flag for the existence of a minified version for the asset
+ * @returns {string}
+ */
 function getAssetUrl(path, hasMinFile) {
+    path = path instanceof SafeString ? path.string : path;
+
     // CASE: favicon - this is special path with its own functionality
     if (path.match(/\/?favicon\.(ico|png)$/)) {
         // @TODO, resolve this - we should only be resolving subdirectory and extension.

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

@@ -3,6 +3,7 @@ const moment = require('moment-timezone');
 const dbBackup = require('../../data/db/backup');
 const exporter = require('../../data/exporter');
 const importer = require('../../data/importer');
+const mediaInliner = require('../../services/media-inliner');
 const errors = require('@tryghost/errors');
 const models = require('../../models');
 const settingsCache = require('../../../shared/settings-cache');
@@ -93,6 +94,22 @@ module.exports = {
         }
     },
 
+    inlineMedia: {
+        permissions: {
+            method: 'importContent'
+        },
+        validation: {
+            options: {
+                include: {
+                    values: ['domains']
+                }
+            }
+        },
+        async query(frame) {
+            return mediaInliner.api.startMediaInliner(frame.data.domains);
+        }
+    },
+
     deleteAllContent: {
         headers: {
             cacheInvalidate: true

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

@@ -9,7 +9,8 @@ module.exports = {
             'limit',
             'order',
             'page',
-            'debug'
+            'debug',
+            'unique'
         ],
         permissions: true,
         query(frame) {

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

@@ -12,10 +12,10 @@ module.exports = {
         }
         let posts = [];
 
-        const tiersModels = await membersService.api.productRepository.list({
+        const tiersModels = await membersService.api?.productRepository.list({
             limit: 'all'
         });
-        const tiers = tiersModels.data ? tiersModels.data.map(tierModel => tierModel.toJSON()) : [];
+        const tiers = tiersModels?.data ? tiersModels.data.map(tierModel => tierModel.toJSON()) : [];
         if (models.meta) {
             for (let model of models.data) {
                 let post = await mappers.posts(model, frame, {tiers});

package/core/server/data/db/backup.js

@@ -3,7 +3,6 @@
 const fs = require('fs-extra');
 
 const path = require('path');
-const Promise = require('bluebird');
 const config = require('../../../shared/config');
 const logging = require('@tryghost/logging');
 const urlUtils = require('../../../shared/url-utils');
@@ -32,7 +31,7 @@ const readBackup = async (filename) => {
     const exists = await fs.pathExists(backupPath);
 
     if (exists) {
-        const backupFile = await fs.readFile(backupPath);
+        const backupFile = await fs.readFile(backupPath, 'utf8');
         return JSON.parse(backupFile);
     } else {
         return null;
@@ -40,23 +39,24 @@ const readBackup = async (filename) => {
 };
 
 /**
- * ## Backup
- * does an export, and stores this in a local file
- * @returns {Promise<*>}
+ * Does an export, and stores this in a local file
+ *
+ * @param {Object} options
+ * @returns {Promise<String>}
  */
 const backup = async function backup(options = {}) {
     logging.info('Creating database backup');
 
-    const props = {
-        data: exporter.doExport(options),
-        filename: exporter.fileName(options)
-    };
+    const filename = await exporter.fileName(options);
+    const data = await exporter.doExport(options);
 
-    const exportResult = await Promise.props(props);
-    const filename = await writeExportFile(exportResult);
+    const filePath = await writeExportFile({
+        data,
+        filename
+    });
 
-    logging.info('Database backup written to: ' + filename);
-    return filename;
+    logging.info(`Database backup written to ${filePath}`);
+    return filePath;
 };
 
 module.exports = {

package/core/server/data/importer/handlers/image.js

@@ -15,7 +15,7 @@ ImageHandler = {
         const store = storage.getStorage('images');
         const baseDirRegex = baseDir ? new RegExp('^' + baseDir + '/') : new RegExp('');
 
-        const imageFolderRegexes = _.map(urlUtils.STATIC_IMAGE_URL_PREFIX.split('/'), function (dir) {
+        const imageFolderRegexes = _.map(store.staticFileURLPrefix.split('/'), function (dir) {
             return new RegExp('^' + dir + '/');
         });
 
@@ -36,7 +36,7 @@ ImageHandler = {
 
         return Promise.all(files.map(function (image) {
             return store.getUniqueFileName(image, image.targetDir).then(function (targetFilename) {
-                image.newPath = urlUtils.urlJoin('/', urlUtils.getSubdir(), urlUtils.STATIC_IMAGE_URL_PREFIX,
+                image.newPath = urlUtils.urlJoin('/', urlUtils.getSubdir(), store.staticFileURLPrefix,
                     path.relative(config.getContentPath('images'), targetFilename));
 
                 return image;

package/core/server/data/importer/import-manager.js

@@ -11,15 +11,19 @@ const debug = require('@tryghost/debug')('import-manager');
 const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
 const ImageHandler = require('./handlers/image');
+const ImporterContentFileHandler = require('@tryghost/importer-handler-content-files');
 const RevueHandler = require('./handlers/revue');
 const JSONHandler = require('./handlers/json');
 const MarkdownHandler = require('./handlers/markdown');
-const ImageImporter = require('./importers/image');
+const ContentFileImporter = require('./importers/ContentFileImporter');
 const RevueImporter = require('@tryghost/importer-revue');
 const DataImporter = require('./importers/data');
 const urlUtils = require('../../../shared/url-utils');
 const {GhostMailer} = require('../../services/mail');
 const jobManager = require('../../services/jobs');
+const mediaStorage = require('../../adapters/storage').getStorage('media');
+const imageStorage = require('../../adapters/storage').getStorage('images');
+const fileStorage = require('../../adapters/storage').getStorage('files');
 
 const emailTemplate = require('./email-template');
 const ghostMailer = new GhostMailer();
@@ -51,15 +55,55 @@ let defaults = {
 
 class ImportManager {
     constructor() {
+        const mediaHandler = new ImporterContentFileHandler({
+            type: 'media',
+            // @NOTE: making the second parameter strict folder "content/media" brakes the glob pattern
+            //        in the importer, so we need to keep it as general "content" unless
+            //        it becomes a strict requirement
+            directories: ['media', 'content'],
+            extensions: config.get('uploads').media.extensions,
+            contentTypes: config.get('uploads').media.contentTypes,
+            contentPath: config.getContentPath('media'),
+            urlUtils: urlUtils,
+            storage: mediaStorage
+        });
+
+        const filesHandler = new ImporterContentFileHandler({
+            type: 'files',
+            // @NOTE: making the second parameter strict folder "content/files" brakes the glob pattern
+            //        in the importer, so we need to keep it as general "content" unless
+            //        it becomes a strict requirement
+            directories: ['files', 'content'],
+            extensions: config.get('uploads').files.extensions,
+            contentTypes: config.get('uploads').files.contentTypes,
+            contentPath: config.getContentPath('files'),
+            urlUtils: urlUtils,
+            storage: fileStorage
+        });
+
+        const imageImporter = new ContentFileImporter({
+            type: 'images',
+            store: imageStorage
+        });
+        const mediaImporter = new ContentFileImporter({
+            type: 'media',
+            store: mediaStorage
+        });
+
+        const contentFilesImporter = new ContentFileImporter({
+            type: 'files',
+            store: fileStorage
+        });
+
         /**
          * @type {Importer[]} importers
          */
-        this.importers = [ImageImporter, RevueImporter, DataImporter];
+        this.importers = [imageImporter, mediaImporter, contentFilesImporter, RevueImporter, DataImporter];
 
         /**
          * @type {Handler[]}
          */
-        this.handlers = [ImageHandler, RevueHandler, JSONHandler, MarkdownHandler];
+        this.handlers = [ImageHandler, mediaHandler, filesHandler, RevueHandler, JSONHandler, MarkdownHandler];
 
         // Keep track of file to cleanup at the end
         /**
@@ -294,7 +338,15 @@ class ImportManager {
      */
     async processFile(file, ext) {
         const fileHandlers = _.filter(this.handlers, function (handler) {
-            return _.includes(handler.extensions, ext);
+            let match = _.includes(handler.extensions, ext);
+
+            // CASE: content file handlers should ignore files in the root directory
+            if (match && handler.directories && handler.directories.length) {
+                const dir = path.dirname(file.path)?.split('/')[1];
+                match = _.includes(handler.directories, dir);
+            }
+
+            return match;
         });
 
         const importData = {};

package/core/server/data/importer/importers/ContentFileImporter.js

@@ -0,0 +1,128 @@
+const _ = require('lodash');
+let replaceImage;
+let preProcessPosts;
+let preProcessTags;
+let preProcessUsers;
+
+replaceImage = function (markdown, image) {
+    if (!markdown) {
+        return;
+    }
+
+    // Normalizes to include a trailing slash if there was one
+    const regex = new RegExp('(/)?' + image.originalPath, 'gm');
+
+    return markdown.replace(regex, image.newPath);
+};
+
+/**
+ * @param {Object} data
+ * @param {Object[]} data.posts
+ * @param {Object} contentFile
+ * @param {String} contentFile.originalPath
+ * @param {String} contentFile.newPath
+ */
+preProcessPosts = function (data, contentFile) {
+    _.each(data.posts, function (post) {
+        post.markdown = replaceImage(post.markdown, contentFile);
+        if (post.html) {
+            post.html = replaceImage(post.html, contentFile);
+        }
+        if (post.feature_image) {
+            post.feature_image = replaceImage(post.feature_image, contentFile);
+        }
+    });
+};
+
+preProcessTags = function (data, image) {
+    _.each(data.tags, function (tag) {
+        if (tag.feature_image) {
+            tag.feature_image = replaceImage(tag.feature_image, image);
+        }
+    });
+};
+
+preProcessUsers = function (data, image) {
+    _.each(data.users, function (user) {
+        if (user.cover_image) {
+            user.cover_image = replaceImage(user.cover_image, image);
+        }
+        if (user.profile_image) {
+            user.profile_image = replaceImage(user.profile_image, image);
+        }
+    });
+};
+
+class ContentFileImporter {
+    /** @property {string} */
+    type;
+
+    /** @property {import('ghost-storage-base')} */
+    #store;
+
+    /**
+     *
+     * @param {Object} deps
+     * @param {'images' | 'media' | 'files'} deps.type - importer type
+     * @param {import('ghost-storage-base')} deps.store
+     */
+    constructor(deps) {
+        this.type = deps.type;
+        this.#store = deps.store;
+    }
+
+    preProcess(importData) {
+        if (this.type === 'images') {
+            if (importData.images && importData.data && importData.data.data) {
+                _.each(importData.images, function (image) {
+                    preProcessPosts(importData.data.data, image);
+                    preProcessTags(importData.data.data, image);
+                    preProcessUsers(importData.data.data, image);
+                });
+            }
+
+            importData.preProcessedByImage = true;
+        }
+
+        // @NOTE: the type === 'media' check does not belong here and should be abstracted away
+        //        to make this importer more generic
+        if (this.type === 'media') {
+            if (importData.media && importData.data && importData.data.data) {
+                _.each(importData.media, function (file) {
+                    preProcessPosts(importData.data.data, file);
+                });
+            }
+
+            importData.preProcessedByMedia = true;
+        }
+
+        if (this.type === 'files') {
+            if (importData.files && importData.data && importData.data.data) {
+                _.each(importData.files, function (file) {
+                    preProcessPosts(importData.data.data, file);
+                });
+            }
+
+            importData.preProcessedByFiles = true;
+        }
+
+        return importData;
+    }
+
+    /**
+     *
+     * @param {Object[]} contentFilesData
+     * @returns
+     */
+    doImport(contentFilesData) {
+        const store = this.#store;
+
+        return Promise.all(contentFilesData.map(function (contentFile) {
+            return store.save(contentFile, contentFile.targetDir).then(function (result) {
+                return {originalPath: contentFile.originalPath, newPath: contentFile.newPath, stored: result};
+            });
+        }));
+    }
+}
+
+module.exports = ContentFileImporter;

package/core/server/data/schema/commands.js

@@ -6,7 +6,6 @@ const tpl = require('@tryghost/tpl');
 const db = require('../db');
 const DatabaseInfo = require('@tryghost/database-info');
 const schema = require('./schema');
-const clients = require('./clients');
 
 const messages = {
     hasPrimaryKeySQLiteError: 'Must use hasPrimaryKeySQLite on an SQLite3 database',
@@ -432,11 +431,15 @@ function deleteTable(table, transaction = db.knex) {
 /**
  * @param {import('knex').Knex} [transaction] - connection to the DB
  */
-function getTables(transaction = db.knex) {
+async function getTables(transaction = db.knex) {
     const client = transaction.client.config.client;
 
-    if (_.includes(_.keys(clients), client)) {
-        return clients[client].getTables(transaction);
+    if (client === 'sqlite3') {
+        const response = await transaction.raw('select * from sqlite_master where type = "table"');
+        return _.reject(_.map(response, 'tbl_name'), name => name === 'sqlite_sequence');
+    } else if (client === 'mysql2') {
+        const response = await transaction.raw('show tables');
+        return _.flatten(_.map(response[0], entry => _.values(entry)));
     }
 
     return Promise.reject(tpl(messages.noSupportForDatabase, {client: client}));
@@ -446,11 +449,15 @@ function getTables(transaction = db.knex) {
  * @param {string} table
  * @param {import('knex').Knex} [transaction] - connection to the DB
  */
-function getIndexes(table, transaction = db.knex) {
+async function getIndexes(table, transaction = db.knex) {
     const client = transaction.client.config.client;
 
-    if (_.includes(_.keys(clients), client)) {
-        return clients[client].getIndexes(table, transaction);
+    if (client === 'sqlite3') {
+        const response = await transaction.raw(`pragma index_list("${table}")`);
+        return _.flatten(_.map(response, 'name'));
+    } else if (client === 'mysql2') {
+        const response = await transaction.raw(`SHOW INDEXES from ${table}`);
+        return _.flatten(_.map(response[0], 'Key_name'));
     }
 
     return Promise.reject(tpl(messages.noSupportForDatabase, {client: client}));
@@ -460,11 +467,15 @@ function getIndexes(table, transaction = db.knex) {
  * @param {string} table
  * @param {import('knex').Knex} [transaction] - connection to the DB
  */
-function getColumns(table, transaction = db.knex) {
+async function getColumns(table, transaction = db.knex) {
     const client = transaction.client.config.client;
 
-    if (_.includes(_.keys(clients), client)) {
-        return clients[client].getColumns(table);
+    if (client === 'sqlite3') {
+        const response = await transaction.raw(`pragma table_info("${table}")`);
+        return _.flatten(_.map(response, 'name'));
+    } else if (client === 'mysql2') {
+        const response = await transaction.raw(`SHOW COLUMNS from ${table}`);
+        return _.flatten(_.map(response[0], 'Field'));
     }
 
     return Promise.reject(tpl(messages.noSupportForDatabase, {client: client}));

package/core/server/models/mention.js

@@ -9,6 +9,19 @@ const Mention = ghostBookshelf.Model.extend({
     enforcedFilters() {
         return 'deleted:false';
     }
+}, {
+    permittedOptions(methodName) {
+        let options = ghostBookshelf.Model.permittedOptions.call(this, methodName);
+        const validOptions = {
+            findPage: ['selectRaw', 'whereRaw']
+        };
+
+        if (validOptions[methodName]) {
+            options = options.concat(validOptions[methodName]);
+        }
+
+        return options;
+    }
 });
 
 module.exports = {

package/core/server/run-update-check.js

@@ -42,7 +42,9 @@ if (parentPort) {
     await settings.init();
     // Finished INIT
 
-    await updateCheck();
+    await updateCheck({
+        rethrowErrors: true
+    });
 
     postParentPortMessage(`Ran update check`);
 

package/core/server/services/media-inliner/index.js

@@ -0,0 +1 @@
+module.exports = require('./service');

package/core/server/services/media-inliner/service.js

@@ -0,0 +1,16 @@
+module.exports = {
+    async init() {
+        const debug = require('@tryghost/debug')('mediaInliner');
+
+        this.api = {
+            // @NOTE: the inlining should become an offloaded job
+            // startMediaInliner: mediaInliner.inlineMedia
+            startMediaInliner: (domains) => {
+                debug('[Inliner] Starting media inlining job for domains: ', domains);
+                return {
+                    status: 'success'
+                };
+            }
+        };
+    }
+};

package/core/server/services/members/stats/members-stats.js

@@ -1,5 +1,4 @@
 const moment = require('moment-timezone');
-const Promise = require('bluebird');
 
 const dateFormat = 'YYYY-MM-DD HH:mm:ss';
 class MembersStats {
@@ -131,14 +130,19 @@ class MembersStats {
         const totalMembers = await this.getTotalMembers();
 
         // perform final calculations in parallel
-        const results = await Promise.props({
-            total: totalMembers,
-            total_in_range: this.getTotalMembersInRange({days, totalMembers, siteTimezone}),
-            total_on_date: this.getTotalMembersOnDatesInRange({days, totalMembers, siteTimezone}),
-            new_today: this.getNewMembersToday({siteTimezone})
-        });
-
-        return results;
+        const [total, totalInRange, totalOnDate, newToday] = await Promise.all([
+            totalMembers,
+            this.getTotalMembersInRange({days, totalMembers, siteTimezone}),
+            this.getTotalMembersOnDatesInRange({days, totalMembers, siteTimezone}),
+            this.getNewMembersToday({siteTimezone})
+        ]);
+
+        return {
+            total,
+            total_in_range: totalInRange,
+            total_on_date: totalOnDate,
+            new_today: newToday
+        };
     }
 }
 

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

@@ -65,7 +65,18 @@ module.exports = class BookshelfMentionRepository {
      * @returns {Promise<Page<import('@tryghost/webmentions/lib/Mention')>>}
      */
     async getPage(options) {
-        const page = await this.#MentionModel.findPage(options);
+        /**
+         * @type {GetPageOptions & {whereRaw?: string}}
+         */
+        const _options = {
+            ...options
+        };
+        delete _options.unique;
+        if (options.unique) {
+            _options.whereRaw = 'NOT EXISTS (select id from mentions as m where m.id > mentions.id and m.source = mentions.source)';
+        }
+
+        const page = await this.#MentionModel.findPage(_options);
 
         return {
             data: await Promise.all(page.data.map(model => this.#modelToMention(model))),

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

@@ -80,11 +80,17 @@ module.exports = class MentionController {
             order = 'created_at asc';
         }
 
+        let unique;
+        if (frame.options.unique && (frame.options.unique === 'true' || frame.options.unique === true)) {
+            unique = true;
+        }
+
         const mentions = await this.#api.listMentions({
             filter: frame.options.filter,
             order,
             limit,
-            page
+            page,
+            unique
         });
 
         const resources = await Promise.all(mentions.data.map((mention) => {

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

@@ -6,14 +6,15 @@ module.exports = class WebmentionMetadata {
      * @returns {Promise<import('@tryghost/webmentions/lib/MentionsAPI').WebmentionMetadata>}
      */
     async fetch(url) {
-        const data = await oembedService.fetchOembedDataFromUrl(url.href, 'bookmark');
+        const data = await oembedService.fetchOembedDataFromUrl(url.href, 'mention');
         const result = {
             siteTitle: data.metadata.publisher,
             title: data.metadata.title,
             excerpt: data.metadata.description,
             author: data.metadata.author,
             image: data.metadata.thumbnail ? new URL(data.metadata.thumbnail) : null,
-            favicon: data.metadata.icon ? new URL(data.metadata.icon) : null
+            favicon: data.metadata.icon ? new URL(data.metadata.icon) : null,
+            body: data.body
         };
         return result;
     }