ghost 5.9.4 → 5.11.0

package/core/server/data/migrations/versions/5.10/2022-08-15-05-34-add-expiry-at-column-to-members-products.js

@@ -0,0 +1,6 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('members_products', 'expiry_at', {
+    type: 'dateTime',
+    nullable: true
+});

package/core/server/data/migrations/versions/5.10/2022-08-16-14-25-add-member-created-events-table.js

@@ -0,0 +1,11 @@
+const {addTable} = require('../../utils');
+
+module.exports = addTable('members_created_events', {
+    id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+    created_at: {type: 'dateTime', nullable: false},
+    member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
+    attribution_id: {type: 'string', maxlength: 24, nullable: true},
+    attribution_type: {type: 'string', maxlength: 50, nullable: true},
+    attribution_url: {type: 'string', maxlength: 2000, nullable: true},
+    source: {type: 'string', maxlength: 50, nullable: false}
+});

package/core/server/data/migrations/versions/5.10/2022-08-16-14-25-add-subscription-created-events-table.js

@@ -0,0 +1,11 @@
+const {addTable} = require('../../utils');
+
+module.exports = addTable('members_subscription_created_events', {
+    id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+    created_at: {type: 'dateTime', nullable: false},
+    member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
+    subscription_id: {type: 'string', maxlength: 24, nullable: false, references: 'members_stripe_customers_subscriptions.id', cascadeDelete: true},
+    attribution_id: {type: 'string', maxlength: 24, nullable: true},
+    attribution_type: {type: 'string', maxlength: 50, nullable: true},
+    attribution_url: {type: 'string', maxlength: 2000, nullable: true}
+});

package/core/server/data/migrations/versions/5.10/2022-08-19-14-15-fix-comments-deletion-strategy.js

@@ -0,0 +1,45 @@
+const {addForeign, dropForeign} = require('../../../schema/commands');
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        logging.info('Adding on delete CASCADE for comments parent_id');
+
+        await dropForeign({
+            fromTable: 'comments',
+            fromColumn: 'parent_id',
+            toTable: 'comments',
+            toColumn: 'id',
+            transaction: knex
+        });
+
+        await addForeign({
+            fromTable: 'comments',
+            fromColumn: 'parent_id',
+            toTable: 'comments',
+            toColumn: 'id',
+            cascadeDelete: true,
+            transaction: knex
+        });
+    },
+    async function down(knex) {
+        logging.info('Restoring foreign key for comments parent_id');
+
+        await dropForeign({
+            fromTable: 'comments',
+            fromColumn: 'parent_id',
+            toTable: 'comments',
+            toColumn: 'id',
+            transaction: knex
+        });
+
+        await addForeign({
+            fromTable: 'comments',
+            fromColumn: 'parent_id',
+            toTable: 'comments',
+            toColumn: 'id',
+            transaction: knex
+        });
+    }
+);

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},
@@ -466,7 +469,8 @@ module.exports = {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
         product_id: {type: 'string', maxlength: 24, nullable: false, references: 'products.id', cascadeDelete: true},
-        sort_order: {type: 'integer', nullable: false, unsigned: true, defaultTo: 0}
+        sort_order: {type: 'integer', nullable: false, unsigned: true, defaultTo: 0},
+        expiry_at: {type: 'dateTime', nullable: true}
     },
     posts_products: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
@@ -474,6 +478,15 @@ module.exports = {
         product_id: {type: 'string', maxlength: 24, nullable: false, references: 'products.id', cascadeDelete: true},
         sort_order: {type: 'integer', nullable: false, unsigned: true, defaultTo: 0}
     },
+    members_created_events: {
+        id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+        created_at: {type: 'dateTime', nullable: false},
+        member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
+        attribution_id: {type: 'string', maxlength: 24, nullable: true},
+        attribution_type: {type: 'string', maxlength: 50, nullable: true},
+        attribution_url: {type: 'string', maxlength: 2000, nullable: true},
+        source: {type: 'string', maxlength: 50, nullable: false}
+    },
     members_cancel_events: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
@@ -594,6 +607,15 @@ module.exports = {
         plan_amount: {type: 'integer', nullable: false},
         plan_currency: {type: 'string', maxLength: 3, nullable: false}
     },
+    members_subscription_created_events: {
+        id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+        created_at: {type: 'dateTime', nullable: false},
+        member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
+        subscription_id: {type: 'string', maxlength: 24, nullable: false, references: 'members_stripe_customers_subscriptions.id', cascadeDelete: true},
+        attribution_id: {type: 'string', maxlength: 24, nullable: true},
+        attribution_type: {type: 'string', maxlength: 50, nullable: true},
+        attribution_url: {type: 'string', maxlength: 2000, nullable: true}
+    },
     offer_redemptions: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         offer_id: {type: 'string', maxlength: 24, nullable: false, references: 'offers.id', cascadeDelete: true},
@@ -754,7 +776,7 @@ module.exports = {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         post_id: {type: 'string', maxlength: 24, nullable: false, unique: false, references: 'posts.id', cascadeDelete: true},
         member_id: {type: 'string', maxlength: 24, nullable: true, unique: false, references: 'members.id', setNullDelete: true},
-        parent_id: {type: 'string', maxlength: 24, nullable: true, unique: false, references: 'comments.id'},
+        parent_id: {type: 'string', maxlength: 24, nullable: true, unique: false, references: 'comments.id', cascadeDelete: true},
         status: {type: 'string', maxlength: 50, nullable: false, defaultTo: 'published', validations: {isIn: [['published', 'hidden', 'deleted']]}},
         html: {type: 'text', maxlength: 1000000000, fieldtype: 'long', nullable: true},
         edited_at: {type: 'dateTime', nullable: true},

package/core/server/lib/image/cached-image-size-from-url.js

@@ -1,52 +1,76 @@
 const debug = require('@tryghost/debug')('utils:image-size-cache');
 const errors = require('@tryghost/errors');
 const logging = require('@tryghost/logging');
+
+/**
+ * @example
+ * {
+ *   height: 50,
+ *   url: 'https://mysite.com/images/cat.jpg',
+ *   width: 50
+ * }
+ * @typedef ImageSizeCache
+ * @type {Object}
+ * @property {string} url image url
+ * @property {number} height image height
+ * @property {number} width image width
+ */
+
 class CachedImageSizeFromUrl {
-    constructor({imageSize}) {
-        this.imageSize = imageSize;
-        this.cache = new Map();
+    /**
+     *
+     * @param {Object} options
+     * @param {(url: string) => Promise<ImageSizeCache>} options.getImageSizeFromUrl - method that resolves images based on URL
+     * @param {Object} options.cache - cache store instance
+     */
+    constructor({getImageSizeFromUrl, cache}) {
+        this.getImageSizeFromUrl = getImageSizeFromUrl;
+        this.cache = cache;
     }
 
     /**
      * Get cached image size from URL
      * Always returns {object} imageSizeCache
      * @param {string} url
-     * @returns {Promise<Object>} imageSizeCache
+     * @returns {Promise<ImageSizeCache>}
      * @description Takes a url and returns image width and height from cache if available.
      * If not in cache, `getImageSizeFromUrl` is called and returns the dimensions in a Promise.
      */
-    getCachedImageSizeFromUrl(url) {
+    async getCachedImageSizeFromUrl(url) {
         if (!url || url === undefined || url === null) {
             return;
         }
-    
-        // image size is not in cache
-        if (!this.cache.has(url)) {
-            return this.imageSize.getImageSizeFromUrl(url).then((res) => {
-                this.cache.set(url, res);
-    
+
+        const cachedImageSize = await this.cache.get(url);
+
+        if (cachedImageSize) {
+            debug('Read image from cache:', url);
+
+            return cachedImageSize;
+        } else {
+            try {
+                const res = await this.getImageSizeFromUrl(url);
+                await this.cache.set(url, res);
+
                 debug('Cached image:', url);
-    
-                return this.cache.get(url);
-            }).catch(errors.NotFoundError, () => {
-                debug('Cached image (not found):', url);
-                // in case of error we just attach the url
-                this.cache.set(url, url);
-    
+
                 return this.cache.get(url);
-            }).catch((err) => {
-                debug('Cached image (error):', url);
-                logging.error(err);
-    
+            } catch (err) {
+                if (err instanceof errors.NotFoundError) {
+                    debug('Cached image (not found):', url);
+                } else {
+                    debug('Cached image (error):', url);
+                    logging.error(err);
+                }
+
                 // in case of error we just attach the url
-                this.cache.set(url, url);
-    
+                await this.cache.set(url, {
+                    url
+                });
+
                 return this.cache.get(url);
-            });
+            }
         }
-        debug('Read image from cache:', url);
-        // returns image size from cache
-        return this.cache.get(url);
     }
 }
 

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/lib/image/image-utils.js

@@ -4,10 +4,13 @@ const Gravatar = require('./gravatar');
 const ImageSize = require('./image-size');
 
 class ImageUtils {
-    constructor({config, urlUtils, settingsCache, storageUtils, storage, validator, request}) {
+    constructor({config, urlUtils, settingsCache, storageUtils, storage, validator, request, cacheStore}) {
         this.blogIcon = new BlogIcon({config, urlUtils, settingsCache, storageUtils});
         this.imageSize = new ImageSize({config, storage, storageUtils, validator, urlUtils, request});
-        this.cachedImageSizeFromUrl = new CachedImageSizeFromUrl({imageSize: this.imageSize});
+        this.cachedImageSizeFromUrl = new CachedImageSizeFromUrl({
+            getImageSizeFromUrl: this.imageSize.getImageSizeFromUrl.bind(this.imageSize),
+            cache: cacheStore
+        });
         this.gravatar = new Gravatar({config, request});
     }
 }

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

@@ -7,4 +7,17 @@ const config = require('../../../shared/config');
 const settingsCache = require('../../../shared/settings-cache');
 const ImageUtils = require('./image-utils');
 
-module.exports = new ImageUtils({config, urlUtils, settingsCache, storageUtils, storage, validator, request});
+const adapterManager = require('../../services/adapter-manager');
+
+const cacheStore = adapterManager.getAdapter('cache:imageSizes');
+
+module.exports = new ImageUtils({
+    config,
+    urlUtils,
+    settingsCache,
+    storageUtils,
+    storage,
+    validator,
+    request,
+    cacheStore
+});

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/api-key.js

@@ -6,6 +6,9 @@ const {Role} = require('./role');
 const ApiKey = ghostBookshelf.Model.extend({
     tableName: 'api_keys',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'api_key',
+
     defaults() {
         const secret = security.secret.create(this.get('type'));
 
@@ -53,24 +56,6 @@ const ApiKey = ghostBookshelf.Model.extend({
         if (this.previous('secret') !== this.get('secret')) {
             this.addAction(model, 'refreshed', options);
         }
-    },
-
-    getAction(event, options) {
-        const actor = this.getActor(options);
-
-        // @NOTE: we ignore internal updates (`options.context.internal`) for now
-        if (!actor) {
-            return;
-        }
-
-        // @TODO: implement context
-        return {
-            event: event,
-            resource_id: this.id || this.previous('id'),
-            resource_type: 'api_key',
-            actor_id: actor.id,
-            actor_type: actor.type
-        };
     }
 }, {
     refreshSecret(data, options) {

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

@@ -7,6 +7,61 @@ const logging = require('@tryghost/logging');
  */
 module.exports = function (Bookshelf) {
     Bookshelf.Model = Bookshelf.Model.extend({
+        /**
+         * Constructs data to be stored in the database with info
+         * on particular actions
+         */
+        getAction(event, options) {
+            const actor = this.getActor(options);
+
+            // @NOTE: we ignore internal updates (`options.context.internal`) for now
+            if (!actor) {
+                return;
+            }
+
+            if (!this.actionsCollectCRUD) {
+                return;
+            }
+
+            let resourceType = this.actionsResourceType;
+
+            if (typeof resourceType === 'function') {
+                resourceType = resourceType.bind(this)();
+            }
+
+            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;
+        },
+
         /**
          * @NOTE:
          *

package/core/server/models/integration.js

@@ -6,6 +6,9 @@ const {NoPermissionError} = require('@tryghost/errors');
 const Integration = ghostBookshelf.Model.extend({
     tableName: 'integrations',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'integration',
+
     relationships: ['api_keys', 'webhooks'],
 
     relationshipBelongsTo: {