ghost 4.22.3 → 4.25.0

package/core/server/data/migrations/versions/4.9/06-add-comped-status.js

@@ -3,6 +3,7 @@ const {createTransactionalMigration} = require('../../utils.js');
 
 module.exports = createTransactionalMigration(
     async function up(knex) {
+        // eslint-disable-next-line no-restricted-syntax
         const compedMemberIds = (await knex('members')
             .select('members.id')
             .innerJoin(

package/core/server/data/migrations/versions/4.9/07-update-comped-members-status-events.js

@@ -15,6 +15,7 @@ module.exports = createTransactionalMigration(
             logging.info(`Found ${compedMembers.length} comped members - checking members_status_events`);
         }
 
+        // eslint-disable-next-line no-restricted-syntax
         for (const member of compedMembers) {
             const mostRecentStatusEvent = await knex('members_status_events')
                 .select('*')

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

@@ -139,7 +139,7 @@ async function hasForeignSQLite({fromTable, fromColumn, toTable, toColumn, trans
     const client = knex.client.config.client;
 
     if (client !== 'sqlite3') {
-        throw new errors.GhostError({
+        throw new errors.InternalServerError({
             message: tpl(messages.hasForeignSQLite3)
         });
     }
@@ -265,7 +265,7 @@ async function hasPrimaryKeySQLite(tableName, transaction) {
     const client = knex.client.config.client;
 
     if (client !== 'sqlite3') {
-        throw new errors.GhostError({
+        throw new errors.InternalServerError({
             message: tpl(messages.hasPrimaryKeySQLiteError)
         });
     }

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

@@ -0,0 +1,340 @@
+const _ = require('lodash');
+const Promise = require('bluebird');
+const logging = require('@tryghost/logging');
+const {sequence} = require('@tryghost/promise');
+
+const models = require('../../../models');
+const baseUtils = require('../../../models/base/utils');
+
+const moment = require('moment');
+
+class FixtureManager {
+    constructor(fixtures) {
+        this.fixtures = fixtures;
+    }
+
+    /**
+     * ### Match Func
+     * Figures out how to match across various combinations of keys and values.
+     * Match can be a string or an array containing 2 strings
+     * Key and Value are the values to be found
+     * Value can also be an array, in which case we look for a match in the array.
+     * @api private
+     * @param {String|Array} match
+     * @param {String|Integer} key
+     * @param {String|Array} [value]
+     * @returns {Function} matching function
+     */
+    static matchFunc(match, key, value) {
+        if (_.isArray(match)) {
+            return function (item) {
+                let valueTest = true;
+
+                if (_.isArray(value)) {
+                    valueTest = value.indexOf(item.get(match[1])) > -1;
+                } else if (value !== 'all') {
+                    valueTest = item.get(match[1]) === value;
+                }
+
+                return item.get(match[0]) === key && valueTest;
+            };
+        }
+
+        return function (item) {
+            key = key === 0 && value ? value : key;
+            return item.get(match) === key;
+        };
+    }
+
+    static matchObj(match, item) {
+        const matchedObj = {};
+
+        if (_.isArray(match)) {
+            _.each(match, (matchProp) => {
+                matchedObj[matchProp] = item.get(matchProp);
+            });
+        } else {
+            matchedObj[match] = item.get(match);
+        }
+
+        return matchedObj;
+    }
+
+    /**
+     * Add All Fixtures
+     *
+     * Helper method to handle adding all fixtures
+     *
+     * @param {object} options
+     * @returns
+     */
+    async addAllFixtures(options) {
+        const localOptions = _.merge({
+            context: {internal: true},
+            migrating: true
+        }, options);
+
+        await Promise.mapSeries(this.fixtures.models, (model) => {
+            logging.info('Model: ' + model.name);
+
+            return this.addFixturesForModel(model, localOptions);
+        });
+
+        await Promise.mapSeries(this.fixtures.relations, (relation) => {
+            logging.info('Relation: ' + relation.from.model + ' to ' + relation.to.model);
+            return this.addFixturesForRelation(relation, localOptions);
+        });
+    }
+
+    /*
+     * Find methods - use the local fixtures
+     */
+
+    /**
+     * ### Find Model Fixture
+     * Finds a model fixture based on model name
+     * @api private
+     * @param {String} modelName
+     * @returns {Object} model fixture
+     */
+    findModelFixture(modelName) {
+        return _.find(this.fixtures.models, (modelFixture) => {
+            return modelFixture.name === modelName;
+        });
+    }
+
+    /**
+     * ### Find Model Fixture Entry
+     * Find a single model fixture entry by model name & a matching expression for the FIND function
+     * @param {String} modelName
+     * @param {String|Object|Function} matchExpr
+     * @returns {Object} model fixture entry
+     */
+    findModelFixtureEntry(modelName, matchExpr) {
+        return _.find(this.findModelFixture(modelName).entries, matchExpr);
+    }
+
+    /**
+     * ### Find Model Fixtures
+     * Find a  model fixture name & a matching expression for the FILTER function
+     * @param {String} modelName
+     * @param {String|Object|Function} matchExpr
+     * @returns {Object} model fixture
+     */
+    findModelFixtures(modelName, matchExpr) {
+        const foundModel = _.cloneDeep(this.findModelFixture(modelName));
+        foundModel.entries = _.filter(foundModel.entries, matchExpr);
+        return foundModel;
+    }
+
+    /**
+     * ### Find Relation Fixture
+     * Find a relation fixture by from & to models
+     * @api private
+     * @param {String} from
+     * @param {String} to
+     * @returns {Object} relation fixture
+     */
+    findRelationFixture(from, to) {
+        return _.find(this.fixtures.relations, (relation) => {
+            return relation.from.model === from && relation.to.model === to;
+        });
+    }
+
+    /**
+     * ### Find Permission Relations For Object
+     * Specialist function can return the permission relation fixture with only entries for a particular object.model
+     * @param {String} objName
+     * @returns {Object} fixture relation
+     */
+    findPermissionRelationsForObject(objName, role) {
+        // Make a copy and delete any entries we don't want
+        const foundRelation = _.cloneDeep(this.findRelationFixture('Role', 'Permission'));
+
+        _.each(foundRelation.entries, (entry, key) => {
+            _.each(entry, (perm, obj) => {
+                if (obj !== objName) {
+                    delete entry[obj];
+                }
+            });
+
+            if (_.isEmpty(entry) || (role && role !== key)) {
+                delete foundRelation.entries[key];
+            }
+        });
+
+        return foundRelation;
+    }
+
+    /******************************************************
+     * From here down, the methods require access to models
+     * But aren't dependent on this.fixtures
+     ******************************************************/
+
+    /**
+     * ### Fetch Relation Data
+     * Before we build relations we need to fetch all of the models from both sides so that we can
+     * use filter and find to quickly locate the correct models.
+     * @api private
+     * @param {{from, to, entries}} relation
+     * @returns {Promise<*>}
+     */
+    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)
+        };
+
+        return Promise.props(props);
+    }
+
+    /**
+     * ### Add Fixtures for Model
+     * Takes a model fixture, with a name and some entries and processes these
+     * into a sequence of promises to get each fixture added.
+     *
+     * @param {{name, entries}} modelFixture
+     * @returns {Promise<any>}
+     */
+    async addFixturesForModel(modelFixture, options = {}) {
+        // Clone the fixtures as they get changed in this function.
+        // The initial blog posts will be added a `published_at` property, which
+        // would change the fixturesHash.
+        modelFixture = _.cloneDeep(modelFixture);
+        // The Post model fixtures need a `published_at` date, where at least the seconds
+        // are different, otherwise `prev_post` and `next_post` helpers won't workd with
+        // them.
+        if (modelFixture.name === 'Post') {
+            _.forEach(modelFixture.entries, (post, index) => {
+                if (!post.published_at) {
+                    post.published_at = moment().add(index, 'seconds');
+                }
+            });
+        }
+
+        const results = await Promise.mapSeries(modelFixture.entries, async (entry) => {
+            let data = {};
+
+            // CASE: if id is specified, only query by id
+            if (entry.id) {
+                data.id = entry.id;
+            } else if (entry.slug) {
+                data.slug = entry.slug;
+            } else {
+                data = _.cloneDeep(entry);
+            }
+
+            if (modelFixture.name === 'Post') {
+                data.status = 'all';
+            }
+
+            const found = await models[modelFixture.name].findOne(data, options);
+            if (!found) {
+                return models[modelFixture.name].add(entry, options);
+            }
+        });
+
+        return {expected: modelFixture.entries.length, done: _.compact(results).length};
+    }
+
+    /**
+     * ## Add Fixtures for Relation
+     * Takes a relation fixtures object, with a from, to and some entries and processes these
+     * into a sequence of promises, to get each fixture added.
+     *
+     * @param {{from, to, entries}} relationFixture
+     * @returns {Promise<any>}
+     */
+    async addFixturesForRelation(relationFixture, options) {
+        const ops = [];
+        let max = 0;
+
+        const data = await this.fetchRelationData(relationFixture, options);
+
+        _.each(relationFixture.entries, (entry, key) => {
+            const fromItem = data.from.find(FixtureManager.matchFunc(relationFixture.from.match, key));
+
+            // CASE: You add new fixtures e.g. a new role in a new release.
+            // As soon as an **older** migration script wants to add permissions for any resource, it iterates over the
+            // permissions for each role. But if the role does not exist yet, it won't find the matching db entry and breaks.
+            if (!fromItem) {
+                logging.warn('Skip: Target database entry not found for key: ' + key);
+                return Promise.resolve();
+            }
+
+            _.each(entry, (value, entryKey) => {
+                let toItems = data.to.filter(FixtureManager.matchFunc(relationFixture.to.match, entryKey, value));
+                max += toItems.length;
+
+                // Remove any duplicates that already exist in the collection
+                toItems = _.reject(toItems, (item) => {
+                    return fromItem
+                        .related(relationFixture.from.relation)
+                        .find((model) => {
+                            const objectToMatch = FixtureManager.matchObj(relationFixture.to.match, item);
+                            return Object.keys(objectToMatch).every((keyToCheck) => {
+                                return model.get(keyToCheck) === objectToMatch[keyToCheck];
+                            });
+                        });
+                });
+
+                if (toItems && toItems.length > 0) {
+                    ops.push(function addRelationItems() {
+                        return baseUtils.attach(
+                            models[relationFixture.from.Model || relationFixture.from.model],
+                            fromItem.id,
+                            relationFixture.from.relation,
+                            toItems,
+                            options
+                        );
+                    });
+                }
+            });
+        });
+
+        const result = await sequence(ops);
+        return {expected: max, done: _(result).map('length').sum()};
+    }
+
+    async removeFixturesForModel(modelFixture, options) {
+        const results = await Promise.mapSeries(modelFixture.entries, async (entry) => {
+            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};
+    }
+
+    async removeFixturesForRelation(relationFixture, options) {
+        const data = await this.fetchRelationData(relationFixture, options);
+        const ops = [];
+
+        _.each(relationFixture.entries, (entry, key) => {
+            const fromItem = data.from.find(FixtureManager.matchFunc(relationFixture.from.match, key));
+
+            _.each(entry, (value, entryKey) => {
+                const toItems = data.to.filter(FixtureManager.matchFunc(relationFixture.to.match, entryKey, value));
+
+                if (toItems && toItems.length > 0) {
+                    ops.push(function detachRelation() {
+                        return baseUtils.detach(
+                            models[relationFixture.from.Model || relationFixture.from.model],
+                            fromItem.id,
+                            relationFixture.from.relation,
+                            toItems,
+                            options
+                        );
+                    });
+                }
+            });
+        });
+
+        return await sequence(ops);
+    }
+}
+
+module.exports = FixtureManager;

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

@@ -1,2 +1,8 @@
-module.exports = require('./fixtures');
-module.exports.utils = require('./utils');
+const FixtureManager = require('./fixture-manager');
+const config = require('../../../../shared/config');
+
+const fixturePath = config.get('paths').fixtures;
+const fixtures = require(fixturePath);
+
+module.exports.FixtureManager = FixtureManager;
+module.exports.fixtureManager = new FixtureManager(fixtures);

package/core/server/ghost-server.js

@@ -107,13 +107,13 @@ class GhostServer {
                 let ghostError;
 
                 if (error.code === 'EADDRINUSE') {
-                    ghostError = new errors.GhostError({
+                    ghostError = new errors.InternalServerError({
                         message: tpl(messages.addressInUse.error),
                         context: tpl(messages.addressInUse.context, {port: config.get('server').port}),
                         help: tpl(messages.addressInUse.help)
                     });
                 } else {
-                    ghostError = new errors.GhostError({
+                    ghostError = new errors.InternalServerError({
                         message: tpl(messages.otherError.error, {errorNumber: error.errno}),
                         context: tpl(messages.otherError.context),
                         help: tpl(messages.otherError.help)

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

@@ -177,7 +177,7 @@ class ImageSize {
                 context: err.url || imagePath
             }));
         }).catch(function (err) {
-            if (errors.utils.isIgnitionError(err)) {
+            if (errors.utils.isGhostError(err)) {
                 return Promise.reject(err);
             }
 
@@ -241,7 +241,7 @@ class ImageSize {
                     }
                 }));
             }).catch((err) => {
-                if (errors.utils.isIgnitionError(err)) {
+                if (errors.utils.isGhostError(err)) {
                     return Promise.reject(err);
                 }
 

package/core/server/models/base/listeners.js

@@ -69,13 +69,13 @@ events.on('settings.timezone.edited', function (settingModel, options) {
                 try {
                     await models.Post.edit(post.toJSON(), _.merge({id: post.id}, options));
                 } catch (err) {
-                    logging.error(new errors.GhostError({
+                    logging.error(new errors.InternalServerError({
                         err
                     }));
                 }
             });
         } catch (err) {
-            logging.error(new errors.GhostError({
+            logging.error(new errors.InternalServerError({
                 err: err,
                 level: 'critical'
             }));

package/core/server/models/member-email-change-event.js

@@ -9,11 +9,11 @@ const MemberEmailChangeEvent = ghostBookshelf.Model.extend({
     }
 }, {
     async edit() {
-        throw new errors.IncorrectUsageError('Cannot edit MemberEmailChangeEvent');
+        throw new errors.IncorrectUsageError({message: 'Cannot edit MemberEmailChangeEvent'});
     },
 
     async destroy() {
-        throw new errors.IncorrectUsageError('Cannot destroy MemberEmailChangeEvent');
+        throw new errors.IncorrectUsageError({message: 'Cannot destroy MemberEmailChangeEvent'});
     }
 });
 

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

@@ -9,11 +9,11 @@ const MemberLoginEvent = ghostBookshelf.Model.extend({
     }
 }, {
     async edit() {
-        throw new errors.IncorrectUsageError('Cannot edit MemberLoginEvent');
+        throw new errors.IncorrectUsageError({message: 'Cannot edit MemberLoginEvent'});
     },
 
     async destroy() {
-        throw new errors.IncorrectUsageError('Cannot destroy MemberLoginEvent');
+        throw new errors.IncorrectUsageError({message: 'Cannot destroy MemberLoginEvent'});
     }
 });
 

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

@@ -11,7 +11,7 @@ const MemberPaidSubscriptionEvent = ghostBookshelf.Model.extend({
     customQuery(qb, options) {
         if (options.aggregateMRRDeltas) {
             if (options.limit || options.filter) {
-                throw new errors.IncorrectUsageError('aggregateMRRDeltas does not work when passed a filter or limit');
+                throw new errors.IncorrectUsageError({message: 'aggregateMRRDeltas does not work when passed a filter or limit'});
             }
             const knex = ghostBookshelf.knex;
             return qb.clear('select')
@@ -33,11 +33,11 @@ const MemberPaidSubscriptionEvent = ghostBookshelf.Model.extend({
         return options;
     },
     async edit() {
-        throw new errors.IncorrectUsageError('Cannot edit MemberPaidSubscriptionEvent');
+        throw new errors.IncorrectUsageError({message: 'Cannot edit MemberPaidSubscriptionEvent'});
     },
 
     async destroy() {
-        throw new errors.IncorrectUsageError('Cannot destroy MemberPaidSubscriptionEvent');
+        throw new errors.IncorrectUsageError({message: 'Cannot destroy MemberPaidSubscriptionEvent'});
     }
 });
 

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

@@ -11,7 +11,7 @@ const MemberPaymentEvent = ghostBookshelf.Model.extend({
     customQuery(qb, options) {
         if (options.aggregatePaymentVolume) {
             if (options.limit || options.filter) {
-                throw new errors.IncorrectUsageError('aggregatePaymentVolume does not work when passed a filter or limit');
+                throw new errors.IncorrectUsageError({message: 'aggregatePaymentVolume does not work when passed a filter or limit'});
             }
             const knex = ghostBookshelf.knex;
             return qb.clear('select')
@@ -33,11 +33,11 @@ const MemberPaymentEvent = ghostBookshelf.Model.extend({
         return options;
     },
     async edit() {
-        throw new errors.IncorrectUsageError('Cannot edit MemberPaymentEvent');
+        throw new errors.IncorrectUsageError({message: 'Cannot edit MemberPaymentEvent'});
     },
 
     async destroy() {
-        throw new errors.IncorrectUsageError('Cannot destroy MemberPaymentEvent');
+        throw new errors.IncorrectUsageError({message: 'Cannot destroy MemberPaymentEvent'});
     }
 });
 

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

@@ -19,15 +19,15 @@ const MemberProductEvent = ghostBookshelf.Model.extend({
 
 }, {
     async edit() {
-        throw new errors.IncorrectUsageError(
-            tpl(messages.cannotPerformAction, 'edit')
-        );
+        throw new errors.IncorrectUsageError({
+            message: tpl(messages.cannotPerformAction, 'edit')
+        });
     },
 
     async destroy() {
-        throw new errors.IncorrectUsageError(
-            tpl(messages.cannotPerformAction, 'destroy')
-        );
+        throw new errors.IncorrectUsageError({
+            message: tpl(messages.cannotPerformAction, 'destroy')
+        });
     }
 });
 

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

@@ -11,7 +11,9 @@ const MemberStatusEvent = ghostBookshelf.Model.extend({
     customQuery(qb, options) {
         if (options.aggregateStatusCounts) {
             if (options.limit || options.filter) {
-                throw new errors.IncorrectUsageError('aggregateStatusCounts does not work when passed a filter or limit');
+                throw new errors.IncorrectUsageError({
+                    message: 'aggregateStatusCounts does not work when passed a filter or limit'
+                });
             }
             const knex = ghostBookshelf.knex;
             return qb.clear('select')
@@ -46,11 +48,11 @@ const MemberStatusEvent = ghostBookshelf.Model.extend({
         return options;
     },
     async edit() {
-        throw new errors.IncorrectUsageError('Cannot edit MemberStatusEvent');
+        throw new errors.IncorrectUsageError({message: 'Cannot edit MemberStatusEvent'});
     },
 
     async destroy() {
-        throw new errors.IncorrectUsageError('Cannot destroy MemberStatusEvent');
+        throw new errors.IncorrectUsageError({message: 'Cannot destroy MemberStatusEvent'});
     }
 });
 

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

@@ -11,7 +11,9 @@ const MemberSubscribeEvent = ghostBookshelf.Model.extend({
     customQuery(qb, options) {
         if (options.aggregateSubscriptionDeltas) {
             if (options.limit || options.filter) {
-                throw new errors.IncorrectUsageError('aggregateSubscriptionDeltas does not work when passed a filter or limit');
+                throw new errors.IncorrectUsageError({
+                    message: 'aggregateSubscriptionDeltas does not work when passed a filter or limit'
+                });
             }
             const knex = ghostBookshelf.knex;
             return qb.clear('select')
@@ -32,11 +34,15 @@ const MemberSubscribeEvent = ghostBookshelf.Model.extend({
         return options;
     },
     async edit() {
-        throw new errors.IncorrectUsageError('Cannot edit MemberSubscribeEvent');
+        throw new errors.IncorrectUsageError({
+            message: 'Cannot edit MemberSubscribeEvent'
+        });
     },
 
     async destroy() {
-        throw new errors.IncorrectUsageError('Cannot destroy MemberSubscribeEvent');
+        throw new errors.IncorrectUsageError({
+            message: 'Cannot destroy MemberSubscribeEvent'
+        });
     }
 });
 

package/core/server/models/relations/authors.js

@@ -324,7 +324,7 @@ module.exports.extendModel = function extendModel(Post, Posts, ghostBookshelf) {
                             .then(() => response);
                     })
                     .catch((err) => {
-                        throw new errors.GhostError({err: err});
+                        throw new errors.InternalServerError({err: err});
                     });
             });
 

package/core/server/models/settings.js

@@ -346,7 +346,7 @@ Settings = ghostBookshelf.Model.extend({
             );
 
             if (validationErrors.length) {
-                throw new errors.ValidationError(validationErrors.join('\n'));
+                throw new errors.ValidationError({message: validationErrors.join('\n')});
             }
         },
         async labs(model) {

package/core/server/services/auth/passwordreset.js

@@ -148,7 +148,7 @@ function doReset(options, tokenParts, settingsAPI) {
             return Promise.reject(err);
         })
         .catch((err) => {
-            if (errors.utils.isIgnitionError(err)) {
+            if (errors.utils.isGhostError(err)) {
                 return Promise.reject(err);
             }
             return Promise.reject(new errors.UnauthorizedError({err: err}));

package/core/server/services/auth/setup.js

@@ -59,7 +59,7 @@ async function setupUser(userData) {
     const owner = await models.User.findOne({role: 'Owner', status: 'all'});
 
     if (!owner) {
-        throw new errors.GhostError({
+        throw new errors.InternalServerError({
             message: tpl(messages.setupUnableToRun)
         });
     }

package/core/server/services/email-analytics/jobs/index.js

@@ -12,7 +12,7 @@ module.exports = {
             !hasScheduled &&
             config.get('emailAnalytics') &&
             config.get('backgroundJobs:emailAnalytics') &&
-            !process.env.NODE_ENV.match(/^testing/)
+            !process.env.NODE_ENV.startsWith('test')
         ) {
             // Don't register email analytics job if we have no emails,
             // processor usage from many sites spinning up threads can be high.