ghost 4.22.2 → 4.24.0

package/core/server/data/migrations/versions/2.28/4-insert-scheduler-integration.js

@@ -1,7 +1,7 @@
 const logging = require('@tryghost/logging');
 const merge = require('lodash/merge');
 const models = require('../../../../models');
-const utils = require('../../../schema/fixtures/utils');
+const {fixtureManager} = require('../../../schema/fixtures');
 
 const _private = {};
 
@@ -15,12 +15,12 @@ _private.printResult = function printResult(result, message) {
 
 _private.addGhostSchedulerIntegration = (options) => {
     const message = 'Adding "Ghost Scheduler" integration';
-    const fixtureIntegration = utils.findModelFixtureEntry('Integration', {slug: 'ghost-scheduler'});
+    const fixtureIntegration = fixtureManager.findModelFixtureEntry('Integration', {slug: 'ghost-scheduler'});
 
     return models.Integration.findOne({slug: fixtureIntegration.slug}, options)
         .then((integration) => {
             if (!integration) {
-                return utils.addFixturesForModel({
+                return fixtureManager.addFixturesForModel({
                     name: 'Integration',
                     entries: [fixtureIntegration]
                 }, options).then(result => _private.printResult(result, message));

package/core/server/data/migrations/versions/4.23/01-truncate-offer-names.js

@@ -0,0 +1,58 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+/**
+ * @param {(val: string) => boolean} exists
+ * @param {string} requested
+ * @param {string} attempt
+ * @param {number} n
+ *
+ * @returns {string}
+ */
+function getUnique(exists, requested, attempt = requested, n = 1) {
+    if (!exists(attempt)) {
+        return attempt;
+    }
+    const newAttempt = requested.slice(0, -n.toString().length) + n;
+    return getUnique(exists, requested, newAttempt, n + 1);
+}
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        const allOffers = await knex
+            .select('id', 'name')
+            .from('offers');
+
+        const offersNeedingTrunctation = allOffers.filter((row) => {
+            return row.name.length >= 40;
+        });
+
+        if (offersNeedingTrunctation.length === 0) {
+            logging.warn('No Offers found needing truncation');
+            return;
+        } else {
+            logging.info(`Found ${offersNeedingTrunctation.length} Offers needing truncation`);
+        }
+
+        const truncatedOffers = offersNeedingTrunctation.reduce((offers, row) => {
+            function exists(name) {
+                return offers.find(offer => offer.name === name) !== undefined;
+            }
+
+            const updatedRow = {
+                id: row.id,
+                name: getUnique(exists, row.name.slice(0, 40))
+            };
+
+            return offers.concat(updatedRow);
+        }, []);
+
+        for (const truncatedOffer of truncatedOffers) {
+            await knex('offers')
+                .update('name', truncatedOffer.name)
+                .where('id', truncatedOffer.id);
+        }
+    },
+    // no-op we've lost the data required to roll this back
+    async function down() {}
+);

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/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.

package/core/server/services/mega/post-email-serializer.js

@@ -3,7 +3,6 @@ const template = require('./template');
 const settingsCache = require('../../../shared/settings-cache');
 const urlUtils = require('../../../shared/url-utils');
 const moment = require('moment-timezone');
-const cheerio = require('cheerio');
 const api = require('../../api');
 const {URL} = require('url');
 const mobiledocLib = require('../../lib/mobiledoc');
@@ -24,6 +23,8 @@ const formatHtmlForEmail = function formatHtmlForEmail(html) {
 
     // convert juiced HTML to a DOM-like interface for further manipulation
     // happens after inlining of CSS so we can change element types without worrying about styling
+
+    const cheerio = require('cheerio');
     const _cheerio = cheerio.load(juicedHtml);
 
     // force all links to open in new tab
@@ -243,6 +244,7 @@ const serialize = async (postModel, options = {isBrowserPreview: false, apiVersi
 
     // perform any email specific adjustments to the mobiledoc->HTML render output
     // body wrapper is required so we can get proper top-level selections
+    const cheerio = require('cheerio');
     let _cheerio = cheerio.load(`<body>${post.html}</body>`);
     // remove leading/trailing HRs
     _cheerio(`
@@ -311,6 +313,8 @@ const serialize = async (postModel, options = {isBrowserPreview: false, apiVersi
 };
 
 function renderEmailForSegment(email, memberSegment) {
+    const cheerio = require('cheerio');
+
     const result = {...email};
     const $ = cheerio.load(result.html);
 

package/core/server/services/mega/segment-parser.js

@@ -1,6 +1,5 @@
-const cheerio = require('cheerio');
-
 const getSegmentsFromHtml = (html) => {
+    const cheerio = require('cheerio');
     const $ = cheerio.load(html);
 
     const allSegments = $('[data-gh-segment]')

package/core/server/services/mega/template.js

@@ -544,60 +544,75 @@ figure blockquote p {
     border-width: 0.8em 0 0.8em 1.5em;
 }
 
-a.kg-nft-card {
+.kg-nft-link {
+    display: block; 
+    text-decoration: none !important; 
+    color: #15212A !important; 
+    font-family: inherit !important;
+    font-size: 14px;
+    line-height: 1.3em;
+    padding-top: 4px; 
+    padding-right: 20px; 
+    padding-left: 20px; 
+    padding-bottom: 4px;
+}
+
+.kg-card-callout {
     display: flex;
-    flex-direction: column;
-    color: #15212A;
-    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif;
-    font-size: 15px;
-    text-decoration: none;
+    margin: 0 0 1.5em 0;
+    padding: 20px 28px;
     border-radius: 3px;
-    border: 1px solid #e5eff5;
-    width: 100%;
-    max-width: 512px;
-    color: #222;
+}
+
+.kg-card-callout p {
+    margin: 0
+}
+
+.kg-card-callout-grey {
+    background: #eef0f2;
+}
+
+.kg-card-callout-white {
     background: #fff;
-    margin: 0 auto;
+    box-shadow: inset 0 0 0 1px #dddedf;
 }
 
-.kg-nft-metadata {
-    padding: 20px;
+.kg-card-callout-blue {
+    background: #E9F6FB;
 }
 
-.kg-nft-image {
-    border-radius: 2px 2px 0 0;
+.kg-card-callout-green {
+    background: #E8F8EA;
 }
 
-.kg-nft-header {
-    display: flex;
-    justify-content: space-between;
-    gap: 20px;
+.kg-card-callout-yellow {
+    background: #FCF4E3;
 }
 
-.kg-nft-title {
-    font-family: inherit;
-    font-size: 19px;
-    font-weight: 700;
-    margin: 0;
-    color: #222;
+.kg-card-callout-red {
+    background: #FBE9E9;
 }
 
-.kg-nft-creator {
-    font-family: inherit;
-    margin: 4px 0 0;
-    color: #ababab;
+.kg-card-callout-pink {
+    background: #FCEEF8;
 }
 
-.kg-nft-creator-name {
-    font-weight: 500;
-    color: #222;
+.kg-card-callout-purple {
+    background: #F2EDFC;
 }
 
-.kg-nft-description {
-    font-family: inherit;
-    line-height: 1.4em;
-    margin: 12px 0 0;
-    color: #222;
+.kg-card-callout-accent {
+    background: ${templateSettings.accentColor || '#15212A'};
+    color: #fff;
+}
+
+.kg-card-callout-accent a {
+    color: #fff;
+}
+
+.kg-callout-emoji {
+    padding-right: 12px;
+    font-size: 20px;
 }
 
 /* -------------------------------------

package/core/server/services/nft-oembed.js

@@ -28,42 +28,28 @@ class NFTOEmbedProvider {
      * @param {URL} url
      * @param {IExternalRequest} externalRequest
      *
-     * @returns {Promise<import('oembed-parser').RichTypeData & Object<string, any>>}
+     * @returns {Promise<object>}
      */
     async getOEmbedData(url, externalRequest) {
         const [match, transaction, asset] = url.pathname.match(OPENSEA_PATH_REGEX);
         if (!match) {
             return null;
         }
-        const result = await externalRequest(`https://api.opensea.io/api/v1/asset/${transaction}/${asset}/`, {
+        const result = await externalRequest(`https://api.opensea.io/api/v1/asset/${transaction}/${asset}/?format=json`, {
             json: true
         });
         return {
             version: '1.0',
-            type: 'rich',
+            type: 'nft',
             title: result.body.name,
             author_name: result.body.creator.user.username,
             author_url: `https://opensea.io/${result.body.creator.user.username}`,
             provider_name: 'OpenSea',
             provider_url: 'https://opensea.io',
-            html: `
-            <a href="${result.body.permalink}" class="kg-nft-card">
-                <img class="kg-nft-image" src="${result.body.image_url}">
-                <div class="kg-nft-metadata">
-                    <div class="kg-nft-header">
-                        <h4 class="kg-nft-title"> ${result.body.name} </h4>
-                    </div>
-                    <div class="kg-nft-creator">
-                        Created by <span class="kg-nft-creator-name">${result.body.creator.user.username}</span>
-                        ${(result.body.collection.name ? `&bull; ${result.body.collection.name}` : ``)}
-                    </div>
-                    ${(result.body.description ? `<p class="kg-nft-description">${result.body.description}</p>` : ``)}
-                </div>
-            </a>
-            `,
-            width: 1000,
-            height: 1000,
-            noIframe: true
+            image_url: result.body.image_url,
+            creator_name: result.body.creator.user.username,
+            description: result.body.description,
+            collection_name: result.body.collection.name
         };
     }
 }