ghost 5.10.1 → 5.11.0

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

@@ -1,6 +1,5 @@
 // NOTE: We must not cache references to membersService.api
 // as it is a getter and may change during runtime.
-const Promise = require('bluebird');
 const moment = require('moment-timezone');
 const errors = require('@tryghost/errors');
 const models = require('../../models');
@@ -253,20 +252,11 @@ module.exports = {
         },
         permissions: true,
         async query(frame) {
-            frame.options.require = true;
-            frame.options.cancelStripeSubscriptions = frame.options.cancel;
-
-            await Promise.resolve(membersService.api.members.destroy({
+            return membersService.api.members.destroy({
                 id: frame.options.id
-            }, frame.options)).catch(models.Member.NotFoundError, () => {
-                throw new errors.NotFoundError({
-                    message: tpl(messages.resourceNotFound, {
-                        resource: 'Member'
-                    })
-                });
+            }, {
+                ...frame.options, require: true, cancelStripeSubscriptions: frame.options.cancel
             });
-
-            return null;
         }
     },
 

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

@@ -49,7 +49,7 @@ module.exports = {
             const offer = await offersService.api.updateOffer({
                 ...frame.data.offers[0],
                 id: frame.options.id
-            });
+            }, frame.options);
 
             if (!offer) {
                 throw new errors.NotFoundError({
@@ -69,7 +69,7 @@ module.exports = {
             cacheInvalidate: true
         },
         async query(frame) {
-            const offer = await offersService.api.createOffer(frame.data.offers[0]);
+            const offer = await offersService.api.createOffer(frame.data.offers[0], frame.options);
             return {
                 data: [offer]
             };

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

@@ -2,7 +2,7 @@ const models = require('../../models');
 const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
 const getPostServiceInstance = require('../../services/posts/posts-service');
-const ALLOWED_INCLUDES = ['tags', 'authors', 'authors.roles', 'tiers'];
+const ALLOWED_INCLUDES = ['tags', 'authors', 'authors.roles', 'tiers', 'count.signups', 'count.conversions'];
 const UNSAFE_ATTRS = ['status', 'authors', 'visibility'];
 
 const messages = {
@@ -186,15 +186,7 @@ module.exports = {
             unsafeAttrs: UNSAFE_ATTRS
         },
         query(frame) {
-            frame.options.require = true;
-
-            return models.Post.destroy(frame.options)
-                .then(() => null)
-                .catch(models.Post.NotFoundError, () => {
-                    return Promise.reject(new errors.NotFoundError({
-                        message: tpl(messages.pageNotFound)
-                    }));
-                });
+            return models.Post.destroy({...frame.options, require: true});
         }
     }
 };

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

@@ -192,15 +192,7 @@ module.exports = {
             unsafeAttrs: unsafeAttrs
         },
         query(frame) {
-            frame.options.require = true;
-
-            return models.Post.destroy(frame.options)
-                .then(() => null)
-                .catch(models.Post.NotFoundError, () => {
-                    return Promise.reject(new errors.NotFoundError({
-                        message: tpl(messages.postNotFound)
-                    }));
-                });
+            return models.Post.destroy({...frame.options, require: true});
         }
     }
 };

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

@@ -101,15 +101,7 @@ module.exports = {
         },
         permissions: true,
         query(frame) {
-            frame.options.require = true;
-
-            return models.Snippet.destroy(frame.options)
-                .then(() => null)
-                .catch(models.Snippet.NotFoundError, () => {
-                    return Promise.reject(new errors.NotFoundError({
-                        message: tpl(messages.snippetNotFound)
-                    }));
-                });
+            return models.Snippet.destroy({...frame.options, require: true});
         }
     }
 };

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

@@ -147,13 +147,7 @@ module.exports = {
         },
         permissions: true,
         query(frame) {
-            return models.Tag.destroy(frame.options)
-                .then(() => null)
-                .catch(models.Tag.NotFoundError, () => {
-                    return Promise.reject(new errors.NotFoundError({
-                        message: tpl(messages.tagNotFound)
-                    }));
-                });
+            return models.Tag.destroy({...frame.options, require: true});
         }
     }
 };

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

@@ -23,7 +23,7 @@ function defaultRelations(frame) {
         return false;
     }
 
-    frame.options.withRelated = ['tags', 'authors', 'authors.roles', 'tiers'];
+    frame.options.withRelated = ['tags', 'authors', 'authors.roles', 'tiers', 'count.signups', 'count.conversions'];
 }
 
 function setDefaultOrder(frame) {

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

@@ -128,7 +128,8 @@ function serializeMember(member, options) {
         email_open_rate: json.email_open_rate,
         email_recipients: json.email_recipients,
         status: json.status,
-        last_seen_at: json.last_seen_at
+        last_seen_at: json.last_seen_at,
+        attribution: json.attribution
     };
 
     if (json.products) {

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

@@ -12,6 +12,7 @@ module.exports = {
                 'logo',
                 'icon',
                 'accent_color',
+                'locale',
                 'url',
                 'version',
                 'sentry_dsn',

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

@@ -32,6 +32,9 @@ const author = (attrs, frame) => {
         delete attrs.status;
         delete attrs.email;
         delete attrs.comment_notifications;
+        delete attrs.free_member_signup_notification;
+        delete attrs.paid_subscription_started_notification;
+        delete attrs.paid_subscription_canceled_notification;
 
         // @NOTE: used for night shift
         delete attrs.accessibility;
@@ -130,9 +133,6 @@ const post = (attrs, frame) => {
 
 const action = (attrs) => {
     if (attrs.actor) {
-        delete attrs.actor_id;
-        delete attrs.resource_id;
-
         if (attrs.actor_type === 'user') {
             attrs.actor = _.pick(attrs.actor, ['id', 'name', 'slug', 'profile_image']);
             attrs.actor.image = attrs.actor.profile_image;
@@ -142,12 +142,11 @@ const action = (attrs) => {
             attrs.actor.image = attrs.actor.icon_image;
             delete attrs.actor.icon_image;
         }
-    } else if (attrs.resource) {
-        delete attrs.actor_id;
-        delete attrs.resource_id;
+    }
 
+    if (attrs.resource) {
         // @NOTE: we only support posts right now
-        attrs.resource = _.pick(attrs.resource, ['id', 'title', 'slug', 'feature_image']);
+        attrs.resource = _.pick(attrs.resource, ['id', 'title', 'slug', 'feature_image', 'name']);
         attrs.resource.image = attrs.resource.feature_image;
         delete attrs.resource.feature_image;
     }

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

@@ -78,14 +78,7 @@ module.exports = {
             }
         },
         query({data, options}) {
-            return models.Webhook.edit(data.webhooks[0], Object.assign(options, {require: true}))
-                .catch(models.Webhook.NotFoundError, () => {
-                    throw new errors.NotFoundError({
-                        message: tpl(messages.resourceNotFound, {
-                            resource: 'Webhook'
-                        })
-                    });
-                });
+            return models.Webhook.edit(data.webhooks[0], {...options, require: true});
         }
     },
 
@@ -130,17 +123,7 @@ module.exports = {
             }
         },
         query(frame) {
-            frame.options.require = true;
-
-            return models.Webhook.destroy(frame.options)
-                .then(() => null)
-                .catch(models.Webhook.NotFoundError, () => {
-                    return Promise.reject(new errors.NotFoundError({
-                        message: tpl(messages.resourceNotFound, {
-                            resource: 'Webhook'
-                        })
-                    }));
-                });
+            return models.Webhook.destroy({...frame.options, require: true});
         }
     }
 };

package/core/server/data/migrations/versions/5.11/2022-08-22-11-03-add-member-alert-settings-columns-to-users.js

@@ -0,0 +1,21 @@
+const {createAddColumnMigration, combineNonTransactionalMigrations} = require('../../utils');
+
+module.exports = combineNonTransactionalMigrations(
+    createAddColumnMigration('users', 'free_member_signup_notification', {
+        type: 'boolean',
+        nullable: false,
+        defaultTo: true
+    }),
+
+    createAddColumnMigration('users', 'paid_subscription_canceled_notification', {
+        type: 'boolean',
+        nullable: false,
+        defaultTo: false
+    }),
+
+    createAddColumnMigration('users', 'paid_subscription_started_notification', {
+        type: 'boolean',
+        nullable: false,
+        defaultTo: true
+    })
+);

package/core/server/data/migrations/versions/5.11/2022-08-23-13-41-backfill-members-created-events.js

@@ -0,0 +1,32 @@
+const ObjectID = require('bson-objectid').default;
+const logging = require('@tryghost/logging');
+
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        const members = await knex('members')
+            .select('id', 'created_at');
+
+        if (members.length === 0) {
+            logging.warn(`Skipping migration because no members found`);
+            return;
+        }
+
+        const toInsert = members.map((member) => {
+            return {
+                id: ObjectID().toHexString(),
+                member_id: member.id,
+                created_at: member.created_at,
+                source: 'member'
+            };
+        });
+
+        logging.info(`Inserting ${toInsert.length} members created events`);
+        await knex.batchInsert('members_created_events', toInsert);
+    },
+    async function down(knex) {
+        logging.info(`Clearing all members created events`);
+        await knex('members_created_events').del();
+    }
+);

package/core/server/data/migrations/versions/5.11/2022-08-23-13-59-fix-page-resource-type.js

@@ -0,0 +1,22 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        logging.info(`Changing Action event 'page' resource_type to 'post'`);
+
+        const affectedRows = await knex('actions')
+            .update({
+                resource_type: 'post',
+                context: JSON.stringify({
+                    type: 'page'
+                })
+            })
+            .where('resource_type', 'page');
+
+        logging.info(`Updated ${affectedRows} Action events from 'page' to 'post'`);
+    },
+    async function down() {
+        // no-op: we don't want to put `pages` back as a resource type
+    }
+);

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

@@ -626,6 +626,9 @@
                     "name": "Ghost",
                     "email": "ghost@example.com",
                     "status": "inactive",
+                    "free_member_signup_notification": true,
+                    "paid_subscription_started_notification": true,
+                    "paid_subscription_canceled_notification": false,
                     "roles": []
                 }
             ]

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

@@ -149,6 +149,9 @@ module.exports = {
         tour: {type: 'text', maxlength: 65535, nullable: true},
         last_seen: {type: 'dateTime', nullable: true},
         comment_notifications: {type: 'boolean', nullable: false, defaultTo: true},
+        free_member_signup_notification: {type: 'boolean', nullable: false, defaultTo: true},
+        paid_subscription_started_notification: {type: 'boolean', nullable: false, defaultTo: true},
+        paid_subscription_canceled_notification: {type: 'boolean', nullable: false, defaultTo: false},
         created_at: {type: 'dateTime', nullable: false},
         created_by: {type: 'string', maxlength: 24, nullable: false},
         updated_at: {type: 'dateTime', nullable: true},

package/core/server/lib/image/gravatar.js

@@ -40,15 +40,16 @@ class Gravatar {
                     image: imageUrl
                 };
             })
-            .catch({statusCode: 404}, function () {
-                return {
-                    image: undefined
-                };
-            })
-            .catch(function () {
+            .catch(function (err) {
+                if (err.statusCode === 404) {
+                    return {
+                        image: undefined
+                    };
+                }
+
                 // ignore error, just resolve with no image url
             });
     }
 }
 
-module.exports = Gravatar;
+module.exports = Gravatar;

package/core/server/lib/image/image-size.js

@@ -163,39 +163,41 @@ class ImageSize {
                 width: dimensions.width,
                 height: dimensions.height
             };
-        }).catch({code: 'URL_MISSING_INVALID'}, (err) => {
-            return Promise.reject(new errors.InternalServerError({
-                message: err.message,
-                code: 'IMAGE_SIZE_URL',
-                statusCode: err.statusCode,
-                context: err.url || imagePath
-            }));
-        }).catch({code: 'ETIMEDOUT'}, {code: 'ESOCKETTIMEDOUT'}, {code: 'ECONNRESET'}, {statusCode: 408}, (err) => {
-            return Promise.reject(new errors.InternalServerError({
-                message: 'Request timed out.',
-                code: 'IMAGE_SIZE_URL',
-                statusCode: err.statusCode,
-                context: err.url || imagePath
-            }));
-        }).catch({code: 'ENOENT'}, {code: 'ENOTFOUND'}, {statusCode: 404}, (err) => {
-            return Promise.reject(new errors.NotFoundError({
-                message: 'Image not found.',
-                code: 'IMAGE_SIZE_URL',
-                statusCode: err.statusCode,
-                context: err.url || imagePath
-            }));
-        }).catch(function (err) {
-            if (errors.utils.isGhostError(err)) {
-                return Promise.reject(err);
-            }
+        }).catch((err) => {
+            if (err.code === 'URL_MISSING_INVALID') {
+                return Promise.reject(new errors.InternalServerError({
+                    message: err.message,
+                    code: 'IMAGE_SIZE_URL',
+                    statusCode: err.statusCode,
+                    context: err.url || imagePath
+                }));
+            } else if (err.code === 'ETIMEDOUT' || err.code === 'ESOCKETTIMEDOUT' || err.code === 'ECONNRESET' || err.statusCode === 408) {
+                return Promise.reject(new errors.InternalServerError({
+                    message: 'Request timed out.',
+                    code: 'IMAGE_SIZE_URL',
+                    statusCode: err.statusCode,
+                    context: err.url || imagePath
+                }));
+            } else if (err.code === 'ENOENT' || err.code === 'ENOTFOUND' || err.statusCode === 404) {
+                return Promise.reject(new errors.NotFoundError({
+                    message: 'Image not found.',
+                    code: 'IMAGE_SIZE_URL',
+                    statusCode: err.statusCode,
+                    context: err.url || imagePath
+                }));
+            } else {
+                if (errors.utils.isGhostError(err)) {
+                    return Promise.reject(err);
+                }
 
-            return Promise.reject(new errors.InternalServerError({
-                message: 'Unknown Request error.',
-                code: 'IMAGE_SIZE_URL',
-                statusCode: err.statusCode,
-                context: err.url || imagePath,
-                err: err
-            }));
+                return Promise.reject(new errors.InternalServerError({
+                    message: 'Unknown Request error.',
+                    code: 'IMAGE_SIZE_URL',
+                    statusCode: err.statusCode,
+                    context: err.url || imagePath,
+                    err: err
+                }));
+            }
         });
     }
 
@@ -237,32 +239,34 @@ class ImageSize {
                     height: dimensions.height
                 };
             })
-            .catch({code: 'ENOENT'}, (err) => {
-                return Promise.reject(new errors.NotFoundError({
-                    message: err.message,
-                    code: 'IMAGE_SIZE_STORAGE',
-                    err: err,
-                    context: filePath,
-                    errorDetails: {
-                        originalPath: imagePath,
-                        reqFilePath: filePath
+            .catch((err) => {
+                if (err.code === 'ENOENT') {
+                    return Promise.reject(new errors.NotFoundError({
+                        message: err.message,
+                        code: 'IMAGE_SIZE_STORAGE',
+                        err: err,
+                        context: filePath,
+                        errorDetails: {
+                            originalPath: imagePath,
+                            reqFilePath: filePath
+                        }
+                    }));
+                } else {
+                    if (errors.utils.isGhostError(err)) {
+                        return Promise.reject(err);
                     }
-                }));
-            }).catch((err) => {
-                if (errors.utils.isGhostError(err)) {
-                    return Promise.reject(err);
-                }
 
-                return Promise.reject(new errors.InternalServerError({
-                    message: err.message,
-                    code: 'IMAGE_SIZE_STORAGE',
-                    err: err,
-                    context: filePath,
-                    errorDetails: {
-                        originalPath: imagePath,
-                        reqFilePath: filePath
-                    }
-                }));
+                    return Promise.reject(new errors.InternalServerError({
+                        message: err.message,
+                        code: 'IMAGE_SIZE_STORAGE',
+                        err: err,
+                        context: filePath,
+                        errorDetails: {
+                            originalPath: imagePath,
+                            reqFilePath: filePath
+                        }
+                    }));
+                }
             });
     }
 

package/core/server/models/action.js

@@ -19,16 +19,6 @@ const Action = ghostBookshelf.Model.extend({
 
     resource() {
         return this.morphTo('resource', ['resource_type', 'resource_id'], ...candidates);
-    },
-
-    toJSON(unfilteredOptions) {
-        const options = Action.filterOptions(unfilteredOptions, 'toJSON');
-        const attrs = ghostBookshelf.Model.prototype.toJSON.call(this, options);
-
-        // @TODO: context is not implemented yet
-        delete attrs.context;
-
-        return attrs;
     }
 }, {
     orderDefaultOptions: function orderDefaultOptions() {

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

@@ -29,14 +29,37 @@ module.exports = function (Bookshelf) {
                 resourceType = resourceType.bind(this)();
             }
 
-            // @TODO: implement context
-            return {
-                event: event,
+            if (!resourceType) {
+                return;
+            }
+
+            let context = {};
+
+            if (this.actionsExtraContext && Array.isArray(this.actionsExtraContext)) {
+                for (const c of this.actionsExtraContext) {
+                    context[c] = this.get(c) || this.previous(c);
+                }
+            }
+
+            if (event === 'deleted') {
+                context.primary_name = (this.previous('title') || this.previous('name'));
+            } else if (['added', 'edited'].includes(event)) {
+                context.primary_name = (this.get('title') || this.get('name') || this.previous('title') || this.previous('name'));
+            }
+
+            const data = {
+                event,
                 resource_id: this.id || this.previous('id'),
                 resource_type: resourceType,
                 actor_id: actor.id,
                 actor_type: actor.type
             };
+
+            if (context && Object.keys(context).length) {
+                data.context = context;
+            }
+
+            return data;
         },
 
         /**

package/core/server/models/member.js

@@ -40,6 +40,12 @@ const Member = ghostBookshelf.Model.extend({
         }, {
             key: 'newsletters',
             replacement: 'newsletters.slug'
+        }, {
+            key: 'signup',
+            replacement: 'signups.attribution_id'
+        }, {
+            key: 'conversion',
+            replacement: 'conversions.attribution_id'
         }];
     },
 
@@ -74,6 +80,18 @@ const Member = ghostBookshelf.Model.extend({
                 joinFrom: 'member_id',
                 joinTo: 'customer_id',
                 joinToForeign: 'customer_id'
+            },
+            signups: {
+                tableName: 'members_created_events',
+                tableNameAs: 'signups',
+                type: 'oneToOne',
+                joinFrom: 'member_id'
+            },
+            conversions: {
+                tableName: 'members_subscription_created_events',
+                tableNameAs: 'conversions',
+                type: 'oneToOne',
+                joinFrom: 'member_id'
             }
         };
     },

package/core/server/models/offer.js

@@ -3,6 +3,9 @@ const ghostBookshelf = require('./base');
 const Offer = ghostBookshelf.Model.extend({
     tableName: 'offers',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'offer',
+
     product() {
         return this.belongsTo('Product', 'product_id', 'id');
     }

package/core/server/models/post.js

@@ -39,9 +39,8 @@ Post = ghostBookshelf.Model.extend({
     tableName: 'posts',
 
     actionsCollectCRUD: true,
-    actionsResourceType: function () {
-        return this.get('type') || this.previous('type');
-    },
+    actionsResourceType: 'post',
+    actionsExtraContext: ['type'],
 
     /**
      * @NOTE

package/core/server/models/product.js

@@ -4,6 +4,9 @@ const _ = require('lodash');
 const Product = ghostBookshelf.Model.extend({
     tableName: 'products',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'product',
+
     defaults: {
         active: true,
         visibility: 'none',

package/core/server/models/settings.js

@@ -97,6 +97,10 @@ Settings = ghostBookshelf.Model.extend({
 
     tableName: 'settings',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'setting',
+    actionsExtraContext: ['key', 'group'],
+
     emitChange: function emitChange(event, options) {
         const eventToTrigger = 'settings' + '.' + event;
         ghostBookshelf.Model.prototype.emitChange.bind(this)(this, eventToTrigger, options);

package/core/server/models/user.js

@@ -65,7 +65,10 @@ User = ghostBookshelf.Model.extend({
             password: security.identifier.uid(50),
             visibility: 'public',
             status: 'active',
-            comment_notifications: true
+            comment_notifications: true,
+            free_member_signup_notification: true,
+            paid_subscription_started_notification: true,
+            paid_subscription_canceled_notification: false
         };
     },
 

package/core/server/services/auth/api-key/admin.js

@@ -181,9 +181,6 @@ const authenticateWithToken = async (req, res, next, {token, JWT_OPTIONS}) => {
             );
 
             req.user = user;
-
-            next();
-            return;
         }
 
         // store the api key on the request for later checks and logging