ghost 5.19.3 → 5.20.0

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

@@ -14,20 +14,26 @@ const messages = {
     noSupportForDatabase: 'No support for database client {client}'
 };
 
-function addTableColumn(tableName, table, columnName, columnSpec = schema[tableName][columnName]) {
+/**
+ * @param {string} tableName
+ * @param {import('knex').knex.TableBuilder} tableBuilder
+ * @param {string} columnName
+ * @param {object} [columnSpec]
+ */
+function addTableColumn(tableName, tableBuilder, columnName, columnSpec = schema[tableName][columnName]) {
     let column;
 
     // creation distinguishes between text with fieldtype, string with maxlength and all others
     if (columnSpec.type === 'text' && Object.prototype.hasOwnProperty.call(columnSpec, 'fieldtype')) {
-        column = table[columnSpec.type](columnName, columnSpec.fieldtype);
+        column = tableBuilder[columnSpec.type](columnName, columnSpec.fieldtype);
     } else if (columnSpec.type === 'string') {
         if (Object.prototype.hasOwnProperty.call(columnSpec, 'maxlength')) {
-            column = table[columnSpec.type](columnName, columnSpec.maxlength);
+            column = tableBuilder[columnSpec.type](columnName, columnSpec.maxlength);
         } else {
-            column = table[columnSpec.type](columnName, 191);
+            column = tableBuilder[columnSpec.type](columnName, 191);
         }
     } else {
-        column = table[columnSpec.type](columnName);
+        column = tableBuilder[columnSpec.type](columnName);
     }
 
     if (Object.prototype.hasOwnProperty.call(columnSpec, 'nullable') && columnSpec.nullable === true) {
@@ -48,6 +54,10 @@ function addTableColumn(tableName, table, columnName, columnSpec = schema[tableN
         // check if table exists?
         column.references(columnSpec.references);
     }
+    if (Object.prototype.hasOwnProperty.call(columnSpec, 'constraintName')) {
+        column.withKeyName(columnSpec.constraintName);
+    }
+
     if (Object.prototype.hasOwnProperty.call(columnSpec, 'cascadeDelete') && columnSpec.cascadeDelete === true) {
         column.onDelete('CASCADE');
     } else if (Object.prototype.hasOwnProperty.call(columnSpec, 'setNullDelete') && columnSpec.setNullDelete === true) {
@@ -61,18 +71,34 @@ function addTableColumn(tableName, table, columnName, columnSpec = schema[tableN
     }
 }
 
+/**
+ * @param {string} tableName
+ * @param {string} column
+ * @param {import('knex').Knex} [transaction]
+ */
 function setNullable(tableName, column, transaction = db.knex) {
     return transaction.schema.table(tableName, function (table) {
         table.setNullable(column);
     });
 }
 
+/**
+ * @param {string} tableName
+ * @param {string} column
+ * @param {import('knex').Knex} [transaction]
+ */
 function dropNullable(tableName, column, transaction = db.knex) {
     return transaction.schema.table(tableName, function (table) {
         table.dropNullable(column);
     });
 }
 
+/**
+ * @param {string} tableName
+ * @param {string} column
+ * @param {import('knex').Knex.Transaction} [transaction]
+ * @param {object} columnSpec
+ */
 async function addColumn(tableName, column, transaction = db.knex, columnSpec) {
     const addColumnBuilder = transaction.schema.table(tableName, function (table) {
         addTableColumn(tableName, table, column, columnSpec);
@@ -85,41 +111,51 @@ async function addColumn(tableName, column, transaction = db.knex, columnSpec) {
         return;
     }
 
-    let sql = addColumnBuilder.toSQL()[0].sql;
+    for (const sqlQuery of addColumnBuilder.toSQL()) {
+        let sql = sqlQuery.sql;
 
-    if (DatabaseInfo.isMySQL(transaction)) {
-        // Guard against an ending semicolon
-        sql = sql.replace(/;\s*$/, '') + ', algorithm=copy';
-    }
+        if (DatabaseInfo.isMySQL(transaction)) {
+            // Guard against an ending semicolon
+            sql = sql.replace(/;\s*$/, '') + ', algorithm=copy';
+        }
 
-    await transaction.raw(sql);
+        await transaction.raw(sql);
+    }
 }
 
+/**
+ * @param {string} tableName
+ * @param {string} column
+ * @param {import('knex').Knex} [transaction]
+ * @param {object} [columnSpec]
+ */
 async function dropColumn(tableName, column, transaction = db.knex, columnSpec = {}) {
     if (Object.prototype.hasOwnProperty.call(columnSpec, 'references')) {
         const [toTable, toColumn] = columnSpec.references.split('.');
-        await dropForeign({fromTable: tableName, fromColumn: column, toTable, toColumn, transaction});
+        await dropForeign({fromTable: tableName, fromColumn: column, toTable, toColumn, constraintName: columnSpec.constraintName, transaction});
     }
 
-    const dropTableBuilder = transaction.schema.table(tableName, function (table) {
+    const dropColumnBuilder = transaction.schema.table(tableName, function (table) {
         table.dropColumn(column);
     });
 
     // Use the default flow for SQLite because .toSQL() is tricky with SQLite when
     // it does the table dance
     if (DatabaseInfo.isSQLite(transaction)) {
-        await dropTableBuilder;
+        await dropColumnBuilder;
         return;
     }
 
-    let sql = dropTableBuilder.toSQL()[0].sql;
+    for (const sqlQuery of dropColumnBuilder.toSQL()) {
+        let sql = sqlQuery.sql;
 
-    if (DatabaseInfo.isMySQL(transaction)) {
-        // Guard against an ending semicolon
-        sql = sql.replace(/;\s*$/, '') + ', algorithm=copy';
-    }
+        if (DatabaseInfo.isMySQL(transaction)) {
+            // Guard against an ending semicolon
+            sql = sql.replace(/;\s*$/, '') + ', algorithm=copy';
+        }
 
-    await transaction.raw(sql);
+        await transaction.raw(sql);
+    }
 }
 
 /**
@@ -127,7 +163,7 @@ async function dropColumn(tableName, column, transaction = db.knex, columnSpec =
  *
  * @param {string} tableName - name of the table to add unique constraint to
  * @param {string|string[]} columns - column(s) to form unique constraint with
- * @param {import('knex')} transaction - connection object containing knex reference
+ * @param {import('knex').Knex} [transaction] - connection object containing knex reference
  */
 async function addUnique(tableName, columns, transaction = db.knex) {
     try {
@@ -154,7 +190,7 @@ async function addUnique(tableName, columns, transaction = db.knex) {
  *
  * @param {string} tableName - name of the table to drop unique constraint from
  * @param {string|string[]} columns - column(s) unique constraint was formed
- * @param {import('knex')} transaction - connection object containing knex reference
+ * @param {import('knex').Knex} transaction - connection object containing knex reference
  */
 async function dropUnique(tableName, columns, transaction = db.knex) {
     try {
@@ -184,7 +220,7 @@ async function dropUnique(tableName, columns, transaction = db.knex) {
  * @param {string} configuration.fromColumn - column of the table to add the foreign key to
  * @param {string} configuration.toTable - name of the table to point the foreign key to
  * @param {string} configuration.toColumn - column of the table to point the foreign key to
- * @param {import('knex')} configuration.transaction - connection object containing knex reference
+ * @param {import('knex').Knex} [configuration.transaction] - connection object containing knex reference
  */
 async function hasForeignSQLite({fromTable, fromColumn, toTable, toColumn, transaction = db.knex}) {
     if (!DatabaseInfo.isSQLite(transaction)) {
@@ -208,11 +244,12 @@ async function hasForeignSQLite({fromTable, fromColumn, toTable, toColumn, trans
  * @param {string} configuration.fromColumn - column of the table to add the foreign key to
  * @param {string} configuration.toTable - name of the table to point the foreign key to
  * @param {string} configuration.toColumn - column of the table to point the foreign key to
+ * @param {string} [configuration.constraintName] - name of the FK to create
  * @param {Boolean} [configuration.cascadeDelete] - adds the "on delete cascade" option if true
  * @param {Boolean} [configuration.setNullDelete] - adds the "on delete SET NULL" option if true
- * @param {import('knex')} configuration.transaction - connection object containing knex reference
+ * @param {import('knex').Knex} [configuration.transaction] - connection object containing knex reference
  */
-async function addForeign({fromTable, fromColumn, toTable, toColumn, cascadeDelete = false, setNullDelete = false, transaction = db.knex}) {
+async function addForeign({fromTable, fromColumn, toTable, toColumn, constraintName, cascadeDelete = false, setNullDelete = false, transaction = db.knex}) {
     if (DatabaseInfo.isSQLite(transaction)) {
         const foreignKeyExists = await hasForeignSQLite({fromTable, fromColumn, toTable, toColumn, transaction});
         if (foreignKeyExists) {
@@ -233,12 +270,18 @@ async function addForeign({fromTable, fromColumn, toTable, toColumn, cascadeDele
         }
 
         await transaction.schema.table(fromTable, function (table) {
+            let fkBuilder;
+
             if (cascadeDelete) {
-                table.foreign(fromColumn).references(`${toTable}.${toColumn}`).onDelete('CASCADE');
+                fkBuilder = table.foreign(fromColumn).references(`${toTable}.${toColumn}`).onDelete('CASCADE');
             } else if (setNullDelete) {
-                table.foreign(fromColumn).references(`${toTable}.${toColumn}`).onDelete('SET NULL');
+                fkBuilder = table.foreign(fromColumn).references(`${toTable}.${toColumn}`).onDelete('SET NULL');
             } else {
-                table.foreign(fromColumn).references(`${toTable}.${toColumn}`);
+                fkBuilder = table.foreign(fromColumn).references(`${toTable}.${toColumn}`);
+            }
+
+            if (constraintName) {
+                fkBuilder.withKeyName(constraintName);
             }
         });
 
@@ -264,9 +307,10 @@ async function addForeign({fromTable, fromColumn, toTable, toColumn, cascadeDele
  * @param {string} configuration.fromColumn - column of the table to add the foreign key to
  * @param {string} configuration.toTable - name of the table to point the foreign key to
  * @param {string} configuration.toColumn - column of the table to point the foreign key to
- * @param {import('knex')} configuration.transaction - connection object containing knex reference
+ * @param {string} [configuration.constraintName] - name of the FK to delete
+ * @param {import('knex').Knex} [configuration.transaction] - connection object containing knex reference
  */
-async function dropForeign({fromTable, fromColumn, toTable, toColumn, transaction = db.knex}) {
+async function dropForeign({fromTable, fromColumn, toTable, toColumn, constraintName, transaction = db.knex}) {
     if (DatabaseInfo.isSQLite(transaction)) {
         const foreignKeyExists = await hasForeignSQLite({fromTable, fromColumn, toTable, toColumn, transaction});
         if (!foreignKeyExists) {
@@ -287,7 +331,7 @@ async function dropForeign({fromTable, fromColumn, toTable, toColumn, transactio
         }
 
         await transaction.schema.table(fromTable, function (table) {
-            table.dropForeign(fromColumn);
+            table.dropForeign(fromColumn, constraintName);
         });
 
         if (DatabaseInfo.isSQLite(transaction)) {
@@ -308,7 +352,7 @@ async function dropForeign({fromTable, fromColumn, toTable, toColumn, transactio
  * Checks if primary key index exists in a table over the given columns.
  *
  * @param {string} tableName - name of the table to check primary key constraint on
- * @param {import('knex')} transaction - connection object containing knex reference
+ * @param {import('knex').Knex} [transaction] - connection object containing knex reference
  */
 async function hasPrimaryKeySQLite(tableName, transaction = db.knex) {
     if (!DatabaseInfo.isSQLite(transaction)){
@@ -328,7 +372,7 @@ async function hasPrimaryKeySQLite(tableName, transaction = db.knex) {
  *
  * @param {string} tableName - name of the table to add primaykey  constraint to
  * @param {string|string[]} columns - column(s) to form primary key constraint with
- * @param {import('knex')} transaction - connection object containing knex reference
+ * @param {import('knex').Knex} [transaction] - connection object containing knex reference
  */
 async function addPrimaryKey(tableName, columns, transaction = db.knex) {
     if (DatabaseInfo.isSQLite(transaction)) {
@@ -359,7 +403,7 @@ async function addPrimaryKey(tableName, columns, transaction = db.knex) {
  * utils if you want that
  *
  * @param {String} table - name of the table to create
- * @param {import('knex').Transaction} transaction - connection to the DB
+ * @param {import('knex').Knex} [transaction] - connection to the DB
  * @param {Object} [tableSpec] - table schema to generate table with
  */
 function createTable(table, transaction = db.knex, tableSpec = schema[table]) {
@@ -377,10 +421,17 @@ function createTable(table, transaction = db.knex, tableSpec = schema[table]) {
     });
 }
 
+/**
+ * @param {string} table
+ * @param {import('knex').Knex} [transaction] - connection to the DB
+ */
 function deleteTable(table, transaction = db.knex) {
     return transaction.schema.dropTableIfExists(table);
 }
 
+/**
+ * @param {import('knex').Knex} [transaction] - connection to the DB
+ */
 function getTables(transaction = db.knex) {
     const client = transaction.client.config.client;
 
@@ -391,6 +442,10 @@ function getTables(transaction = db.knex) {
     return Promise.reject(tpl(messages.noSupportForDatabase, {client: client}));
 }
 
+/**
+ * @param {string} table
+ * @param {import('knex').Knex} [transaction] - connection to the DB
+ */
 function getIndexes(table, transaction = db.knex) {
     const client = transaction.client.config.client;
 
@@ -401,6 +456,10 @@ function getIndexes(table, transaction = db.knex) {
     return Promise.reject(tpl(messages.noSupportForDatabase, {client: client}));
 }
 
+/**
+ * @param {string} table
+ * @param {import('knex').Knex} [transaction] - connection to the DB
+ */
 function getColumns(table, transaction = db.knex) {
     const client = transaction.client.config.client;
 
@@ -441,20 +500,20 @@ function createColumnMigration(...migrations) {
 }
 
 module.exports = {
-    createTable: createTable,
-    deleteTable: deleteTable,
-    getTables: getTables,
-    getIndexes: getIndexes,
-    addUnique: addUnique,
-    dropUnique: dropUnique,
-    addPrimaryKey: addPrimaryKey,
-    addForeign: addForeign,
-    dropForeign: dropForeign,
-    addColumn: addColumn,
-    dropColumn: dropColumn,
-    setNullable: setNullable,
-    dropNullable: dropNullable,
-    getColumns: getColumns,
+    createTable,
+    deleteTable,
+    getTables,
+    getIndexes,
+    addUnique,
+    dropUnique,
+    addPrimaryKey,
+    addForeign,
+    dropForeign,
+    addColumn,
+    dropColumn,
+    setNullable,
+    dropNullable,
+    getColumns,
     createColumnMigration,
     // NOTE: below are exposed for testing purposes only
     _hasForeignSQLite: hasForeignSQLite,

package/core/server/data/schema/fixtures/fixtures.json

@@ -618,6 +618,16 @@
                     "name": "Report comments",
                     "action_type": "report",
                     "object_type": "comment"
+                },
+                {
+                    "name": "Browse links",
+                    "action_type": "browse",
+                    "object_type": "link"
+                },
+                {
+                    "name": "Edit links",
+                    "action_type": "edit",
+                    "object_type": "link"
                 }
             ]
         },
@@ -747,7 +757,8 @@
                     "members_stripe_connect": "auth",
                     "newsletter": "all",
                     "explore": "read",
-                    "comment": "all"
+                    "comment": "all",
+                    "link": "all"
                 },
                 "DB Backup Integration": {
                     "db": "all"
@@ -781,7 +792,8 @@
                     "offer": ["browse", "read", "add", "edit"],
                     "newsletter": ["browse", "read", "add", "edit"],
                     "explore": "read",
-                    "comment": "all"
+                    "comment": "all",
+                    "link": "all"
                 },
                 "Editor": {
                     "notification": "all",

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

@@ -630,7 +630,7 @@ module.exports = {
             }
         },
         member_id: {type: 'string', maxlength: 24, nullable: false, unique: false, references: 'members.id', cascadeDelete: true},
-        tier_id: {type: 'string', maxlength: 24, nullable: true, unique: false, references: 'products.id'},
+        tier_id: {type: 'string', maxlength: 24, nullable: false, unique: false, references: 'products.id'},
 
         // These are null if type !== 'paid'
         cadence: {
@@ -657,6 +657,7 @@ module.exports = {
     members_stripe_customers_subscriptions: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         customer_id: {type: 'string', maxlength: 255, nullable: false, unique: false, references: 'members_stripe_customers.customer_id', cascadeDelete: true},
+        ghost_subscription_id: {type: 'string', maxlength: 24, nullable: true, references: 'subscriptions.id', constraintName: 'mscs_ghost_subscription_id_foreign', cascadeDelete: true},
         subscription_id: {type: 'string', maxlength: 255, nullable: false, unique: true},
         stripe_price_id: {type: 'string', maxlength: 255, nullable: false, unique: false, index: true, defaultTo: ''},
         status: {type: 'string', maxlength: 50, nullable: false},

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

@@ -72,7 +72,7 @@ module.exports = function (Bookshelf) {
          *
          * We protect adding too many and uncontrolled events.
          *
-         * We could embedd adding actions more nicely in the future e.g. plugin.
+         * We could embed adding actions more nicely in the future e.g. plugin.
          */
         addAction: (model, event, options) => {
             if (!model.wasChanged()) {

package/core/server/models/email-recipient.js

@@ -3,6 +3,20 @@ const ghostBookshelf = require('./base');
 const EmailRecipient = ghostBookshelf.Model.extend({
     tableName: 'email_recipients',
     hasTimestamps: false,
+    
+    filterRelations: function filterRelations() {
+        return {
+            email: {
+                // Mongo-knex doesn't support belongsTo relations
+                tableName: 'emails',
+                tableNameAs: 'email',
+                type: 'manyToMany',
+                joinTable: 'email_recipients',
+                joinFrom: 'id',
+                joinTo: 'email_id'
+            }
+        };
+    },
 
     email() {
         return this.belongsTo('Email', 'email_id');

package/core/server/models/email.js

@@ -81,11 +81,7 @@ const Email = ghostBookshelf.Model.extend({
 
         model.emitChange('deleted', options);
     }
-}, {
-    post() {
-        return this.belongsTo('Post');
-    }
-});
+}, {});
 
 const Emails = ghostBookshelf.Collection.extend({
     model: Email

package/core/server/models/member-click-event.js

@@ -10,7 +10,31 @@ const MemberClickEvent = ghostBookshelf.Model.extend({
 
     member() {
         return this.belongsTo('Member', 'member_id', 'id');
+    },
+
+    filterExpansions: function filterExpansions() {
+        const expansions = [{
+            key: 'post_id',
+            replacement: 'link.post_id'
+        }];
+
+        return expansions;
+    },
+
+    filterRelations() {
+        return {
+            link: {
+                // Mongo-knex doesn't support belongsTo relations
+                tableName: 'redirects',
+                tableNameAs: 'link',
+                type: 'manyToMany',
+                joinTable: 'members_click_events',
+                joinFrom: 'id',
+                joinTo: 'redirect_id'
+            }
+        };
     }
+
 }, {
     async edit() {
         throw new errors.IncorrectUsageError({message: 'Cannot edit MemberClickEvent'});

package/core/server/models/member-paid-subscription-event.js

@@ -25,6 +25,21 @@ const MemberPaidSubscriptionEvent = ghostBookshelf.Model.extend({
                 .groupByRaw('currency, DATE(created_at)')
                 .orderByRaw('DATE(created_at)');
         }
+    },
+
+    filterRelations() {
+        return {
+            subscriptionCreatedEvent: {
+                // Mongo-knex doesn't support belongsTo relations
+                tableName: 'members_subscription_created_events',
+                tableNameAs: 'subscriptionCreatedEvent',
+                type: 'manyToMany',
+                joinTable: 'members_paid_subscription_events',
+                joinFrom: 'id',
+                joinToForeign: 'subscription_id',
+                joinTo: 'subscription_id'
+            }
+        };
     }
 }, {
     permittedOptions(methodName) {

package/core/server/models/post.js

@@ -236,6 +236,17 @@ Post = ghostBookshelf.Model.extend({
     },
 
     orderRawQuery: function orderRawQuery(field, direction, withRelated) {
+        if (field === 'sentiment') {
+            if (withRelated.includes('count.sentiment')) {
+                // Internally sentiment can be included via the count.sentiment relation. We can do a quick optimisation of the query in that case.
+                return {
+                    orderByRaw: `count__sentiment ${direction}`
+                };
+            }
+            return {
+                orderByRaw: `(select AVG(score) from \`members_feedback\` where posts.id = members_feedback.post_id) ${direction}`
+            };
+        }
         if (field === 'email.open_rate' && withRelated && withRelated.indexOf('email') > -1) {
             return {
                 // *1.0 is needed on one of the columns to prevent sqlite from
@@ -1346,6 +1357,26 @@ Post = ghostBookshelf.Model.extend({
                         .as('count__paid_conversions');
                 });
             },
+            /**
+             * Combination of sigups and paid conversions, but unique per member
+             */
+            conversions(modelOrCollection) {
+                modelOrCollection.query('columns', 'posts.*', (qb) => {
+                    qb.count('*')
+                        .from('k')
+                        .with('k', (q) => {
+                            q.select('member_id')
+                                .from('members_subscription_created_events')
+                                .whereRaw('posts.id = members_subscription_created_events.attribution_id')
+                                .union(function () {
+                                    this.select('member_id')
+                                        .from('members_created_events')
+                                        .whereRaw('posts.id = members_created_events.attribution_id');
+                                });
+                        })
+                        .as('count__conversions');
+                });
+            },
             clicks(modelOrCollection) {
                 modelOrCollection.query('columns', 'posts.*', (qb) => {
                     qb.countDistinct('members_click_events.member_id')
@@ -1357,7 +1388,7 @@ Post = ghostBookshelf.Model.extend({
             },
             sentiment(modelOrCollection) {
                 modelOrCollection.query('columns', 'posts.*', (qb) => {
-                    qb.select(qb.client.raw('ROUND(AVG(score) * 100)'))
+                    qb.select(qb.client.raw('COALESCE(ROUND(AVG(score) * 100), 0)'))
                         .from('members_feedback')
                         .whereRaw('posts.id = members_feedback.post_id')
                         .as('count__sentiment');

package/core/server/models/redirect.js

@@ -53,6 +53,7 @@ const Redirect = ghostBookshelf.Model.extend({
                     qb.countDistinct('members_click_events.member_id')
                         .from('members_click_events')
                         .whereRaw('redirects.id = members_click_events.redirect_id')
+                        .whereRaw('redirects.updated_at <= members_click_events.created_at')
                         .as('count__clicks');
                 });
             }

package/core/server/services/audience-feedback/index.js

@@ -1,4 +1,5 @@
 const urlUtils = require('../../../shared/url-utils');
+const urlService = require('../../services/url');
 const FeedbackRepository = require('./FeedbackRepository');
 
 class AudienceFeedbackServiceWrapper {
@@ -22,6 +23,7 @@ class AudienceFeedbackServiceWrapper {
 
         // Expose the service
         this.service = new AudienceFeedbackService({
+            urlService,
             config: {
                 baseURL: new URL(urlUtils.urlFor('home', true))
             }

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

@@ -18,7 +18,7 @@ module.exports = class LinkRedirectRepository {
     }
 
     /**
-     * @param {InstanceType<LinkRedirect>} linkRedirect 
+     * @param {InstanceType<LinkRedirect>} linkRedirect
      * @returns {Promise<void>}
      */
     async save(linkRedirect) {
@@ -36,10 +36,14 @@ module.exports = class LinkRedirectRepository {
     }
 
     fromModel(model) {
+        // Store if link has been edited
+        const edited = model.get('created_at')?.getTime() !== model.get('updated_at')?.getTime();
+
         return new LinkRedirect({
             id: model.id,
             from: new URL(this.#trimLeadingSlash(model.get('from')), this.#urlUtils.urlFor('home', true)),
-            to: new URL(model.get('to'))
+            to: new URL(model.get('to')),
+            edited
         });
     }
 
@@ -55,10 +59,17 @@ module.exports = class LinkRedirectRepository {
         return result;
     }
 
+    async getFilteredIds(options) {
+        const linkRows = await this.#LinkRedirect.getFilteredCollectionQuery(options)
+            .select('redirects.id')
+            .distinct();
+        return linkRows.map(row => row.id);
+    }
+
     /**
-     * 
-     * @param {URL} url 
-     * @returns {Promise<InstanceType<LinkRedirect>|undefined>} linkRedirect 
+     *
+     * @param {URL} url
+     * @returns {Promise<InstanceType<LinkRedirect>|undefined>} linkRedirect
      */
     async getByURL(url) {
         // Strip subdirectory from path

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

@@ -1,4 +1,5 @@
 const {FullPostLink} = require('@tryghost/link-tracking');
+const _ = require('lodash');
 
 /**
  * @typedef {import('bson-objectid').default} ObjectID
@@ -22,8 +23,8 @@ module.exports = class PostLinkRepository {
     }
 
     /**
-     * 
-     * @param {*} options 
+     *
+     * @param {*} options
      * @returns {Promise<InstanceType<FullPostLink>[]>}
      */
     async getAll(options) {
@@ -48,6 +49,29 @@ module.exports = class PostLinkRepository {
         return result;
     }
 
+    async updateLinks(linkIds, updateData, options) {
+        const bulkUpdateOptions = _.pick(options, ['transacting']);
+
+        const bulkActionResult = await this.#LinkRedirect.bulkEdit(linkIds, 'redirects', {
+            ...bulkUpdateOptions,
+            data: updateData
+        });
+
+        return {
+            bulk: {
+                action: 'updateLink',
+                meta: {
+                    stats: {
+                        successful: bulkActionResult.successful,
+                        unsuccessful: bulkActionResult.unsuccessful
+                    },
+                    errors: bulkActionResult.errors,
+                    unsuccessfulData: bulkActionResult.unsuccessfulData
+                }
+            }
+        };
+    }
+
     /**
      * @param {PostLink} postLink
      * @returns {Promise<void>}