ghost 5.14.2 → 5.16.0

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

@@ -4,7 +4,8 @@ const {ValidationError} = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
 
 const messages = {
-    invalidVisibilityFilter: 'Invalid filter in visibility_filter property'
+    invalidVisibilityFilter: 'Invalid filter in visibility_filter property',
+    onlySingleContentSource: 'It\'s only possible to save mobiledoc or lexical properties, not both'
 };
 
 const validateVisibility = async function (frame) {
@@ -33,15 +34,29 @@ const validateVisibility = async function (frame) {
     }
 };
 
+const validateSingleContentSource = async function (frame) {
+    if (!frame.data.posts?.[0]) {
+        return;
+    }
+
+    const [post] = frame.data.posts;
+    if (post.mobiledoc && post.lexical) {
+        return Promise.reject(new ValidationError({
+            message: tpl(messages.onlySingleContentSource),
+            property: 'lexical'
+        }));
+    }
+};
+
 module.exports = {
-    add(apiConfig, frame) {
-        return jsonSchema.validate(...arguments).then(() => {
-            return validateVisibility(frame);
-        });
+    async add(apiConfig, frame) {
+        await jsonSchema.validate(...arguments);
+        await validateVisibility(frame);
+        await validateSingleContentSource(frame);
     },
-    edit(apiConfig, frame) {
-        return jsonSchema.validate(...arguments).then(() => {
-            return validateVisibility(frame);
-        });
+    async edit(apiConfig, frame) {
+        await jsonSchema.validate(...arguments);
+        await validateVisibility(frame);
+        await validateSingleContentSource(frame);
     }
 };

package/core/server/data/exporter/table-lists.js

@@ -21,6 +21,7 @@ const BACKUP_TABLES = [
     'tokens',
     'sessions',
     'mobiledoc_revisions',
+    'post_revisions',
     'email_batches',
     'email_recipients',
     'members_cancel_events',
@@ -37,7 +38,9 @@ const BACKUP_TABLES = [
     'comments',
     'comment_likes',
     'comment_reports',
-    'jobs'
+    'jobs',
+    'link_redirects',
+    'members_link_click_events'
 ];
 
 // NOTE: exposing only tables which are going to be included in a "default" export file

package/core/server/data/migrations/utils/settings.js

@@ -32,9 +32,7 @@ function addSetting({key, value, type, group}) {
                     group,
                     type,
                     created_at: now,
-                    created_by: MIGRATION_USER,
-                    updated_at: now,
-                    updated_by: MIGRATION_USER
+                    created_by: MIGRATION_USER
                 });
         },
         async function down(connection) {

package/core/server/data/migrations/versions/5.15/2022-09-12-16-10-add-posts-lexical-column.js

@@ -0,0 +1,8 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('posts', 'lexical', {
+    type: 'text',
+    maxlength: 1000000000,
+    fieldtype: 'long',
+    nullable: true
+});

package/core/server/data/migrations/versions/5.15/2022-09-14-12-46-add-email-track-clicks-setting.js

@@ -0,0 +1,8 @@
+const {addSetting} = require('../../utils');
+
+module.exports = addSetting({
+    key: 'email_track_clicks',
+    value: 'true',
+    type: 'boolean',
+    group: 'email'
+});

package/core/server/data/migrations/versions/5.15/2022-09-16-08-22-add-post-revisions-table.js

@@ -0,0 +1,9 @@
+const {addTable} = require('../../utils');
+
+module.exports = addTable('post_revisions', {
+    id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+    post_id: {type: 'string', maxlength: 24, nullable: false, index: true},
+    lexical: {type: 'text', maxlength: 1000000000, fieldtype: 'long', nullable: true},
+    created_at_ts: {type: 'bigInteger', nullable: false},
+    created_at: {type: 'dateTime', nullable: false}
+});

package/core/server/data/migrations/versions/5.16/2022-09-19-09-04-add-link-redirects-table.js

@@ -0,0 +1,10 @@
+const {addTable} = require('../../utils');
+
+module.exports = addTable('link_redirects', {
+    id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+    from: {type: 'string', maxlength: 2000, nullable: false},
+    to: {type: 'string', maxlength: 2000, nullable: false},
+    post_id: {type: 'string', maxlength: 24, nullable: true, unique: false, references: 'posts.id', setNullDelete: true},
+    created_at: {type: 'dateTime', nullable: false},
+    updated_at: {type: 'dateTime', nullable: true}
+});

package/core/server/data/migrations/versions/5.16/2022-09-19-09-05-add-members-link-click-events-table.js

@@ -0,0 +1,8 @@
+const {addTable} = require('../../utils');
+
+module.exports = addTable('members_link_click_events', {
+    id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+    member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
+    link_id: {type: 'string', maxlength: 24, nullable: false, references: 'link_redirects.id', cascadeDelete: true},
+    created_at: {type: 'dateTime', nullable: false}
+});

package/core/server/data/migrations/versions/5.16/2022-09-19-17-44-add-referrer-columns-to-member-events-table.js

@@ -0,0 +1,21 @@
+const {createAddColumnMigration, combineNonTransactionalMigrations} = require('../../utils');
+
+module.exports = combineNonTransactionalMigrations(
+    createAddColumnMigration('members_created_events', 'referrer_source', {
+        type: 'string',
+        maxlength: 191,
+        nullable: true
+    }),
+
+    createAddColumnMigration('members_created_events', 'referrer_medium', {
+        type: 'string',
+        maxlength: 191,
+        nullable: true
+    }),
+
+    createAddColumnMigration('members_created_events', 'referrer_url', {
+        type: 'string',
+        maxlength: 2000,
+        nullable: true
+    })
+);

package/core/server/data/migrations/versions/5.16/2022-09-19-17-44-add-referrer-columns-to-subscription-events-table.js

@@ -0,0 +1,21 @@
+const {createAddColumnMigration, combineNonTransactionalMigrations} = require('../../utils');
+
+module.exports = combineNonTransactionalMigrations(
+    createAddColumnMigration('members_subscription_created_events', 'referrer_source', {
+        type: 'string',
+        maxlength: 191,
+        nullable: true
+    }),
+
+    createAddColumnMigration('members_subscription_created_events', 'referrer_medium', {
+        type: 'string',
+        maxlength: 191,
+        nullable: true
+    }),
+
+    createAddColumnMigration('members_subscription_created_events', 'referrer_url', {
+        type: 'string',
+        maxlength: 2000,
+        nullable: true
+    })
+);

package/core/server/data/schema/default-settings/default-settings.json

@@ -360,6 +360,14 @@
             },
             "type": "boolean"
         },
+        "email_track_clicks": {
+            "defaultValue": "true",
+            "validations": {
+                "isEmpty": false,
+                "isIn": [["true", "false"]]
+            },
+            "type": "boolean"
+        },
         "email_verification_required": {
             "defaultValue": "false",
             "validations": {

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

@@ -45,6 +45,7 @@ module.exports = {
         title: {type: 'string', maxlength: 2000, nullable: false, validations: {isLength: {max: 255}}},
         slug: {type: 'string', maxlength: 191, nullable: false},
         mobiledoc: {type: 'text', maxlength: 1000000000, fieldtype: 'long', nullable: true},
+        lexical: {type: 'text', maxlength: 1000000000, fieldtype: 'long', nullable: true},
         html: {type: 'text', maxlength: 1000000000, fieldtype: 'long', nullable: true},
         comment_id: {type: 'string', maxlength: 50, nullable: true},
         plaintext: {type: 'text', maxlength: 1000000000, fieldtype: 'long', nullable: true},
@@ -386,6 +387,13 @@ module.exports = {
         created_at_ts: {type: 'bigInteger', nullable: false},
         created_at: {type: 'dateTime', nullable: false}
     },
+    post_revisions: {
+        id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+        post_id: {type: 'string', maxlength: 24, nullable: false, index: true},
+        lexical: {type: 'text', maxlength: 1000000000, fieldtype: 'long', nullable: true},
+        created_at_ts: {type: 'bigInteger', nullable: false},
+        created_at: {type: 'dateTime', nullable: false}
+    },
     members: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         uuid: {type: 'string', maxlength: 36, nullable: true, unique: true, validations: {isUUID: true}},
@@ -489,6 +497,9 @@ 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},
         source: {
             type: 'string', maxlength: 50, nullable: false, validations: {
                 isIn: [['member', 'import', 'system', 'api', 'admin']]
@@ -626,7 +637,10 @@ module.exports = {
                 isIn: [['url', 'post', 'page', 'author', 'tag']]
             }
         },
-        attribution_url: {type: 'string', maxlength: 2000, nullable: true}
+        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}
     },
     offer_redemptions: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
@@ -821,5 +835,19 @@ module.exports = {
         finished_at: {type: 'dateTime', nullable: true},
         created_at: {type: 'dateTime', nullable: false},
         updated_at: {type: 'dateTime', nullable: true}
+    },
+    link_redirects: {
+        id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+        from: {type: 'string', maxlength: 2000, nullable: false},
+        to: {type: 'string', maxlength: 2000, nullable: false},
+        post_id: {type: 'string', maxlength: 24, nullable: true, unique: false, references: 'posts.id', setNullDelete: true},
+        created_at: {type: 'dateTime', nullable: false},
+        updated_at: {type: 'dateTime', nullable: true}
+    },
+    members_link_click_events: {
+        id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+        member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
+        link_id: {type: 'string', maxlength: 24, nullable: false, references: 'link_redirects.id', cascadeDelete: true},
+        created_at: {type: 'dateTime', nullable: false}
     }
 };

package/core/server/lib/lexical.js

@@ -0,0 +1,12 @@
+let lexicalHtmlRenderer;
+
+module.exports = {
+    get lexicalHtmlRenderer() {
+        if (!lexicalHtmlRenderer) {
+            const LexicalHtmlRenderer = require('@tryghost/kg-lexical-html-renderer');
+            lexicalHtmlRenderer = new LexicalHtmlRenderer();
+        }
+
+        return lexicalHtmlRenderer;
+    }
+};

package/core/server/models/base/plugins/user-type.js

@@ -39,13 +39,11 @@ module.exports = function (Bookshelf) {
             /**
              * @NOTE:
              *
-             * This is a dirty hotfix for v0.1 only.
-             * The `x_by` columns are getting deprecated soon (https://github.com/TryGhost/Ghost/issues/10286).
+             * This is a dirty fix until we get rid of all the x_by columns
+             * @deprecated x_by columns are deprecated as of v1.0 - instead we should use the actions table
+             * see https://github.com/TryGhost/Ghost/issues/10286.
              *
-             * We return the owner ID '1' in case an integration updates or creates
-             * resources. v0.1 will continue to use the `x_by` columns. v0.1 does not support integrations.
-             * API v2 will introduce a new feature to solve inserting/updating resources
-             * from users or integrations. API v2 won't expose `x_by` columns anymore.
+             * We return the owner ID '1' in case an integration updates or creates resources.
              *
              * ---
              *

package/core/server/models/link-redirect.js

@@ -0,0 +1,65 @@
+const ghostBookshelf = require('./base');
+const urlUtils = require('../../shared/url-utils');
+
+const LinkRedirect = ghostBookshelf.Model.extend({
+    tableName: 'link_redirects',
+
+    post() {
+        return this.belongsTo('Post', 'post_id');
+    },
+
+    formatOnWrite(attrs) {
+        if (attrs.to) {
+            attrs.to = urlUtils.absoluteToTransformReady(attrs.to);
+        }
+
+        return attrs;
+    },
+
+    parse() {
+        const attrs = ghostBookshelf.Model.prototype.parse.apply(this, arguments);
+
+        if (attrs.to) {
+            attrs.to = urlUtils.transformReadyToAbsolute(attrs.to);
+        }
+
+        return attrs;
+    }
+}, {
+    orderDefaultRaw(options) {
+        if (options.withRelated && options.withRelated.includes('count.clicks')) {
+            return '`count__clicks` DESC, `to` DESC';
+        }
+        return '`to` DESC';
+    },
+
+    permittedOptions(methodName) {
+        let options = ghostBookshelf.Model.permittedOptions.call(this, methodName);
+        const validOptions = {
+            findAll: ['filter', 'columns', 'withRelated']
+        };
+
+        if (validOptions[methodName]) {
+            options = options.concat(validOptions[methodName]);
+        }
+
+        return options;
+    },
+
+    countRelations() {
+        return {
+            clicks(modelOrCollection) {
+                modelOrCollection.query('columns', 'link_redirects.*', (qb) => {
+                    qb.countDistinct('members_link_click_events.member_id')
+                        .from('members_link_click_events')
+                        .whereRaw('link_redirects.id = members_link_click_events.link_id')
+                        .as('count__clicks');
+                });
+            }
+        };
+    }
+});
+
+module.exports = {
+    LinkRedirect: ghostBookshelf.model('LinkRedirect', LinkRedirect)
+};

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

@@ -0,0 +1,26 @@
+const errors = require('@tryghost/errors');
+const ghostBookshelf = require('./base');
+
+const MemberLinkClickEvent = ghostBookshelf.Model.extend({
+    tableName: 'members_link_click_events',
+
+    link() {
+        return this.belongsTo('LinkRedirect', 'link_id');
+    },
+
+    member() {
+        return this.belongsTo('Member', 'member_id', 'id');
+    }
+}, {
+    async edit() {
+        throw new errors.IncorrectUsageError({message: 'Cannot edit MemberLinkClickEvent'});
+    },
+
+    async destroy() {
+        throw new errors.IncorrectUsageError({message: 'Cannot destroy MemberLinkClickEvent'});
+    }
+});
+
+module.exports = {
+    MemberLinkClickEvent: ghostBookshelf.model('MemberLinkClickEvent', MemberLinkClickEvent)
+};

package/core/server/models/post-revision.js

@@ -0,0 +1,35 @@
+const ghostBookshelf = require('./base');
+
+const PostRevision = ghostBookshelf.Model.extend({
+    tableName: 'post_revisions'
+}, {
+    permittedOptions(methodName) {
+        let options = ghostBookshelf.Model.permittedOptions.call(this, methodName);
+        const validOptions = {
+            findAll: ['filter', 'columns']
+        };
+
+        if (validOptions[methodName]) {
+            options = options.concat(validOptions[methodName]);
+        }
+
+        return options;
+    },
+
+    orderDefaultRaw() {
+        return 'created_at_ts DESC';
+    },
+
+    toJSON(unfilteredOptions) {
+        const options = PostRevision.filterOptions(unfilteredOptions, 'toJSON');
+        const attrs = ghostBookshelf.Model.prototype.toJSON.call(this, options);
+
+        // CASE: only for internal accuracy
+        delete attrs.created_at_ts;
+        return attrs;
+    }
+});
+
+module.exports = {
+    PostRevision: ghostBookshelf.model('PostRevision', PostRevision)
+};

package/core/server/models/post.js

@@ -13,6 +13,7 @@ const config = require('../../shared/config');
 const settingsCache = require('../../shared/settings-cache');
 const limitService = require('../services/limits');
 const mobiledocLib = require('../lib/mobiledoc');
+const lexicalLib = require('../lib/lexical');
 const relations = require('./relations');
 const urlUtils = require('../../shared/url-utils');
 const {Tag} = require('./tag');
@@ -25,10 +26,15 @@ const messages = {
     expectedPublishedAtInFuture: 'Date must be at least {cannotScheduleAPostBeforeInMinutes} minutes in the future.',
     untitled: '(Untitled)',
     notEnoughPermission: 'You do not have permission to perform this action',
-    invalidNewsletter: 'The newsletter parameter doesn\'t match any active newsletter.'
+    invalidNewsletter: 'The newsletter parameter doesn\'t match any active newsletter.',
+    invalidMobiledocStructure: 'Invalid mobiledoc structure.',
+    invalidMobiledocStructureHelp: 'https://ghost.org/docs/publishing/',
+    invalidLexicalStructure: 'Invalid lexical structure.',
+    invalidLexicalStructureHelp: 'https://ghost.org/docs/publishing/'
 };
 
 const MOBILEDOC_REVISIONS_COUNT = 10;
+const POST_REVISIONS_COUNT = 10;
 const ALL_STATUSES = ['published', 'draft', 'scheduled', 'sent'];
 
 let Post;
@@ -90,7 +96,7 @@ Post = ghostBookshelf.Model.extend({
         };
     },
 
-    relationships: ['tags', 'authors', 'mobiledoc_revisions', 'posts_meta', 'tiers'],
+    relationships: ['tags', 'authors', 'mobiledoc_revisions', 'post_revisions', 'posts_meta', 'tiers'],
 
     // NOTE: look up object, not super nice, but was easy to implement
     relationshipBelongsTo: {
@@ -128,6 +134,7 @@ Post = ghostBookshelf.Model.extend({
         // transform URLs from __GHOST_URL__ to absolute
         [
             'mobiledoc',
+            'lexical',
             'html',
             'plaintext',
             'custom_excerpt',
@@ -156,6 +163,7 @@ Post = ghostBookshelf.Model.extend({
                     cardTransformers: mobiledocLib.cards
                 }
             },
+            lexical: 'lexicalToTransformReady',
             html: 'htmlToTransformReady',
             plaintext: 'plaintextToTransformReady',
             custom_excerpt: 'htmlToTransformReady',
@@ -596,7 +604,7 @@ Post = ghostBookshelf.Model.extend({
             });
         }
 
-        if (!this.get('mobiledoc')) {
+        if (!this.get('mobiledoc') && !this.get('lexical')) {
             this.set('mobiledoc', JSON.stringify(mobiledocLib.blankDocument));
         }
 
@@ -610,20 +618,46 @@ Post = ghostBookshelf.Model.extend({
         // CASE: ?force_rerender=true passed via Admin API
         // CASE: html is null, but mobiledoc exists (only important for migrations & importing)
         if (
-            this.hasChanged('mobiledoc')
-            || options.force_rerender
-            || (!this.get('html') && (options.migrating || options.importing))
+            !this.get('lexical') &&
+            (
+                this.hasChanged('mobiledoc')
+                || options.force_rerender
+                || (!this.get('html') && (options.migrating || options.importing))
+            )
         ) {
             try {
                 this.set('html', mobiledocLib.mobiledocHtmlRenderer.render(JSON.parse(this.get('mobiledoc'))));
             } catch (err) {
                 throw new errors.ValidationError({
-                    message: 'Invalid mobiledoc structure.',
+                    message: tpl(messages.invalidMobiledocStructure),
                     help: 'https://ghost.org/docs/publishing/'
                 });
             }
         }
 
+        // CASE: lexical has changed, generate html
+        // CASE: ?force_rerender=true passed via Admin API
+        // CASE: html is null, but lexical exists (only important for migrations & importing)
+        if (
+            !this.get('mobiledoc') &&
+            (
+                this.hasChanged('lexical')
+                || options.force_rerender
+                || (!this.get('html') && (options.migrating || options.importing))
+            )
+        ) {
+            try {
+                this.set('html', lexicalLib.lexicalHtmlRenderer.render(this.get('lexical')));
+            } catch (err) {
+                throw new errors.ValidationError({
+                    message: tpl(messages.invalidLexicalStructure),
+                    context: err.message,
+                    property: 'lexical',
+                    help: tpl(messages.invalidLexicalStructureHelp)
+                });
+            }
+        }
+
         if (this.hasChanged('html') || !this.get('plaintext')) {
             let plaintext;
 
@@ -750,7 +784,7 @@ Post = ghostBookshelf.Model.extend({
         }
 
         // CASE: Handle mobiledoc backups/revisions. This is a pure database feature.
-        if (model.hasChanged('mobiledoc') && !options.importing && !options.migrating) {
+        if (model.hasChanged('mobiledoc') && !model.get('lexical') && !options.importing && !options.migrating) {
             ops.push(function updateRevisions() {
                 return ghostBookshelf.model('MobiledocRevision')
                     .findAll(Object.assign({
@@ -794,6 +828,39 @@ Post = ghostBookshelf.Model.extend({
             });
         }
 
+        // CASE: Handle post backups/revisions. This is a pure database feature.
+        if (model.hasChanged('lexical') && !model.get('mobiledoc') && !options.importing && !options.migrating) {
+            ops.push(function updateRevisions() {
+                return ghostBookshelf.model('PostRevision')
+                    .findAll(Object.assign({
+                        filter: `post_id:${model.id}`,
+                        columns: ['id']
+                    }, _.pick(options, 'transacting')))
+                    .then((revisions) => {
+                        // Store previous + latest lexical content
+                        if (!revisions.length && options.method !== 'insert') {
+                            model.set('post_revisions', [{
+                                post_id: model.id,
+                                lexical: model.previous('lexical'),
+                                created_at_ts: Date.now() - 1
+                            }, {
+                                post_id: model.id,
+                                lexical: model.get('lexical'),
+                                created_at_ts: Date.now()
+                            }]);
+                        } else {
+                            const revisionsJSON = revisions.toJSON().slice(0, POST_REVISIONS_COUNT - 1);
+
+                            model.set('post_revisions', revisionsJSON.concat([{
+                                post_id: model.id,
+                                lexical: model.get('lexical'),
+                                created_at_ts: Date.now()
+                            }]));
+                        }
+                    });
+            });
+        }
+
         if (this.get('tiers')) {
             this.set('tiers', this.get('tiers').map(t => ({
                 id: t.id
@@ -831,6 +898,10 @@ Post = ghostBookshelf.Model.extend({
         return this.hasMany('MobiledocRevision', 'post_id');
     },
 
+    post_revisions() {
+        return this.hasMany('PostRevision', 'post_id');
+    },
+
     posts_meta: function postsMeta() {
         return this.hasOne('PostsMeta', 'post_id');
     },
@@ -901,6 +972,7 @@ Post = ghostBookshelf.Model.extend({
 
         // CASE: never expose the revisions
         delete attrs.mobiledoc_revisions;
+        delete attrs.post_revisions;
 
         // If the current column settings allow it...
         if (!options.columns || (options.columns && options.columns.indexOf('primary_tag') > -1)) {
@@ -974,7 +1046,7 @@ Post = ghostBookshelf.Model.extend({
         return filter;
     }
 }, {
-    allowedFormats: ['mobiledoc', 'html', 'plaintext'],
+    allowedFormats: ['mobiledoc', 'lexical', 'html', 'plaintext'],
 
     orderDefaultOptions: function orderDefaultOptions() {
         return {
@@ -1273,6 +1345,15 @@ Post = ghostBookshelf.Model.extend({
                         .whereRaw('posts.id = members_subscription_created_events.attribution_id')
                         .as('count__conversions');
                 });
+            },
+            clicks(modelOrCollection) {
+                modelOrCollection.query('columns', 'posts.*', (qb) => {
+                    qb.countDistinct('members_link_click_events.member_id')
+                        .from('members_link_click_events')
+                        .join('link_redirects', 'members_link_click_events.link_id', 'link_redirects.id')
+                        .whereRaw('posts.id = link_redirects.post_id')
+                        .as('count__clicks');
+                });
             }
         };
     }

package/core/server/services/bulk-email/bulk-email-processor.js

@@ -7,14 +7,13 @@ const logging = require('@tryghost/logging');
 const models = require('../../models');
 const MailgunClient = require('@tryghost/mailgun-client');
 const sentry = require('../../../shared/sentry');
-const labs = require('../../../shared/labs');
 const debug = require('@tryghost/debug')('mega');
 const postEmailSerializer = require('../mega/post-email-serializer');
 const configService = require('../../../shared/config');
 const settingsCache = require('../../../shared/settings-cache');
 
 const messages = {
-    error: 'The email service was unable to send an email batch.'
+    error: 'The email service received an error from mailgun and was unable to send.'
 };
 
 const mailgunClient = new MailgunClient({config: configService, settings: settingsCache});
@@ -173,10 +172,8 @@ module.exports = {
             // Load newsletter data on email
             await emailBatchModel.relations.email.getLazyRelation('newsletter', {require: false, ...knexOptions});
 
-            if (labs.isSet('newsletterPaywall')) {
-                // Load post data on email - for content gating on paywall
-                await emailBatchModel.relations.email.getLazyRelation('post', {require: false, ...knexOptions});
-            }
+            // Load post data on email - for content gating on paywall
+            await emailBatchModel.relations.email.getLazyRelation('post', {require: false, ...knexOptions});
 
             // send the email
             const sendResponse = await this.send(emailBatchModel.relations.email.toJSON(), recipientRows, memberSegment);
@@ -254,11 +251,13 @@ module.exports = {
             const response = await mailgunClient.send(emailData, recipientData, replacements);
             debug(`sent message (${Date.now() - startTime}ms)`);
             return response;
-        } catch (error) {
-            // REF: possible mailgun errors https://documentation.mailgun.com/en/latest/api-intro.html#errors
+        } catch (err) {
             let ghostError = new errors.EmailError({
-                err: error,
-                context: tpl(messages.error),
+                err,
+                message: tpl(messages.error),
+                context: `Mailgun Error ${err.error.status}: ${err.error.details}`,
+                // REF: possible mailgun errors https://documentation.mailgun.com/en/latest/api-intro.html#errors
+                help: `https://ghost.org/docs/newsletters/#bulk-email-configuration`,
                 code: 'BULK_EMAIL_SEND_FAILED'
             });