ghost 5.19.3 → 5.21.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/default-settings/default-settings.json

@@ -295,6 +295,14 @@
         "members_yearly_price_id": {
             "defaultValue": null,
             "type": "string"
+        },
+        "members_track_sources": {
+            "defaultValue": "true",
+            "validations": {
+                "isEmpty": false,
+                "isIn": [["true", "false"]]
+            },
+            "type": "boolean"
         }
     },
     "portal": {

package/core/server/data/schema/fixtures/fixture-manager.js

@@ -1,5 +1,4 @@
 const _ = require('lodash');
-const Promise = require('bluebird');
 const logging = require('@tryghost/logging');
 const {sequence} = require('@tryghost/promise');
 
@@ -83,16 +82,16 @@ class FixtureManager {
         const userRolesRelation = this.fixtures.relations.find(r => r.from.relation === 'roles');
         await this.addFixturesForRelation(userRolesRelation, localOptions);
 
-        await Promise.mapSeries(this.fixtures.models.filter(m => !['User', 'Role'].includes(m.name)), (model) => {
+        await sequence(this.fixtures.models.filter(m => !['User', 'Role'].includes(m.name)).map(model => () => {
             logging.info('Model: ' + model.name);
 
             return this.addFixturesForModel(model, localOptions);
-        });
+        }));
 
-        await Promise.mapSeries(this.fixtures.relations.filter(r => r.from.relation !== 'roles'), (relation) => {
+        await sequence(this.fixtures.relations.filter(r => r.from.relation !== 'roles').map(relation => () => {
             logging.info('Relation: ' + relation.from.model + ' to ' + relation.to.model);
             return this.addFixturesForRelation(relation, localOptions);
-        });
+        }));
     }
 
     /*
@@ -191,12 +190,15 @@ class FixtureManager {
     fetchRelationData(relation, options) {
         const fromOptions = _.extend({}, options, {withRelated: [relation.from.relation]});
 
-        const props = {
-            from: models[relation.from.model].findAll(fromOptions),
-            to: models[relation.to.model].findAll(options)
-        };
+        const fromRelations = models[relation.from.model].findAll(fromOptions);
+        const toRelations = models[relation.to.model].findAll(options);
 
-        return Promise.props(props);
+        return Promise.all([fromRelations, toRelations]).then(([from, to]) => {
+            return {
+                from: from,
+                to: to
+            };
+        });
     }
 
     /**
@@ -223,7 +225,7 @@ class FixtureManager {
             });
         }
 
-        const results = await Promise.mapSeries(modelFixture.entries, async (entry) => {
+        const results = await sequence(modelFixture.entries.map(entry => async () => {
             let data = {};
 
             // CASE: if id is specified, only query by id
@@ -243,7 +245,7 @@ class FixtureManager {
             if (!found) {
                 return models[modelFixture.name].add(entry, options);
             }
-        });
+        }));
 
         return {expected: modelFixture.entries.length, done: _.compact(results).length};
     }
@@ -308,12 +310,12 @@ class FixtureManager {
     }
 
     async removeFixturesForModel(modelFixture, options) {
-        const results = await Promise.mapSeries(modelFixture.entries, async (entry) => {
+        const results = await sequence(modelFixture.entries.map(entry => async () => {
             const found = models[modelFixture.name].findOne(entry.id ? {id: entry.id} : entry, options);
             if (found) {
                 return models[modelFixture.name].destroy(_.extend(options, {id: found.id}));
             }
-        });
+        }));
 
         return {expected: modelFixture.entries.length, done: results.length};
     }

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

@@ -517,7 +517,8 @@ module.exports = {
             type: 'string', maxlength: 50, nullable: false, validations: {
                 isIn: [['member', 'import', 'system', 'api', 'admin']]
             }
-        }
+        },
+        batch_id: {type: 'string', maxlength: 24, nullable: true}
     },
     members_cancel_events: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
@@ -630,7 +631,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 +658,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},
@@ -696,7 +698,8 @@ module.exports = {
         attribution_url: {type: 'string', maxlength: 2000, nullable: true},
         referrer_source: {type: 'string', maxlength: 191, nullable: true},
         referrer_medium: {type: 'string', maxlength: 191, nullable: true},
-        referrer_url: {type: 'string', maxlength: 2000, nullable: true}
+        referrer_url: {type: 'string', maxlength: 2000, nullable: true},
+        batch_id: {type: 'string', maxlength: 24, nullable: true}
     },
     offer_redemptions: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
@@ -782,6 +785,7 @@ module.exports = {
         plaintext: {type: 'text', maxlength: 1000000000, fieldtype: 'long', nullable: true},
         track_opens: {type: 'boolean', nullable: false, defaultTo: false},
         track_clicks: {type: 'boolean', nullable: false, defaultTo: false},
+        feedback_enabled: {type: 'boolean', nullable: false, defaultTo: false},
         submitted_at: {type: 'dateTime', nullable: false},
         newsletter_id: {type: 'string', maxlength: 24, nullable: true, references: 'newsletters.id'},
         created_at: {type: 'dateTime', 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/base/plugins/crud.js

@@ -108,6 +108,18 @@ module.exports = function (Bookshelf) {
                 options.order = this.orderDefaultOptions();
             }
 
+            if (options.selectRaw) {
+                itemCollection.query((qb) => {
+                    qb.select(qb.client.raw(options.selectRaw));
+                });
+            }
+
+            if (options.whereRaw) {
+                itemCollection.query((qb) => {
+                    qb.whereRaw(options.whereRaw);
+                });
+            }
+
             const response = await itemCollection.fetchPage(options);
             // Attributes are being filtered here, so they are not leaked into calling layer
             // where models are serialized to json and do not do more filtering.

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

@@ -11,6 +11,7 @@ const Email = ghostBookshelf.Model.extend({
             recipient_filter: 'status:-free',
             track_opens: false,
             track_clicks: false,
+            feedback_enabled: false,
             delivered_count: 0,
             opened_count: 0,
             failed_count: 0
@@ -81,11 +82,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'});
@@ -18,6 +42,19 @@ const MemberClickEvent = ghostBookshelf.Model.extend({
 
     async destroy() {
         throw new errors.IncorrectUsageError({message: 'Cannot destroy MemberClickEvent'});
+    },
+
+    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;
     }
 });
 

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

@@ -8,6 +8,13 @@ const MemberCreatedEvent = ghostBookshelf.Model.extend({
         return this.belongsTo('Member', 'member_id', 'id');
     },
 
+    /**
+     * The subscription created event that happend at the same time (if any)
+     */
+    subscriptionCreatedEvent() {
+        return this.belongsTo('SubscriptionCreatedEvent', 'batch_id', 'batch_id');
+    },
+
     postAttribution() {
         return this.belongsTo('Post', 'attribution_id', 'id');   
     },
@@ -18,6 +25,22 @@ const MemberCreatedEvent = ghostBookshelf.Model.extend({
 
     tagAttribution() {
         return this.belongsTo('Tag', 'attribution_id', 'id');   
+    },
+    
+    filterRelations() {
+        return {
+            subscriptionCreatedEvent: {
+                // Mongo-knex doesn't support belongsTo relations
+                tableName: 'members_subscription_created_events',
+                tableNameAs: 'subscriptionCreatedEvent',
+                type: 'manyToMany',
+                joinTable: 'members_created_events',
+                joinFrom: 'id',
+                joinToForeign: 'batch_id',
+                joinTo: 'batch_id',
+                joinType: 'leftJoin'
+            }
+        };
     }
 }, {
     async edit() {