ghost 4.22.1 → 4.23.0

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

@@ -517,10 +517,12 @@ figure blockquote p {
     display: block;
     text-decoration: none !important;
 }
+
 .kg-video-preview table {
     background-size: cover;
     min-height: 200px; /* for when images aren't loaded */
 }
+
 .kg-video-play-button {
     height: 2em;
     width: 3em;
@@ -530,6 +532,7 @@ figure blockquote p {
     font-size: 1em; /* change this to resize */
     background-color: rgba(0,0,0,0.85);
 }
+
 .kg-video-play-button div {
     display: block;
     width: 0;
@@ -541,6 +544,72 @@ figure blockquote p {
     border-width: 0.8em 0 0.8em 1.5em;
 }
 
+.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;
+    margin: 0 0 1.5em 0;
+    padding: 20px 28px;
+    border-radius: 3px;
+}
+
+.kg-card-callout p {
+    margin: 0
+}
+
+.kg-card-callout-grey {
+    background: #eef0f2;
+}
+
+.kg-card-callout-white {
+    background: #fff;
+    box-shadow: inset 0 0 0 1px #dddedf;
+}
+
+.kg-card-callout-blue {
+    background: #E9F6FB;
+}
+
+.kg-card-callout-green {
+    background: #E8F8EA;
+}
+
+.kg-card-callout-yellow {
+    background: #FCF4E3;
+}
+
+.kg-card-callout-red {
+    background: #FBE9E9;
+}
+
+.kg-card-callout-pink {
+    background: #FCEEF8;
+}
+
+.kg-card-callout-purple {
+    background: #F2EDFC;
+}
+
+.kg-card-callout-accent {
+    background: var(--ghost-accent-color);
+    color: #fff;
+}
+
+.kg-callout-emoji {
+    padding-right: 12px;
+    font-size: 20px;
+}
 
 /* -------------------------------------
     HEADER, FOOTER, MAIN
@@ -614,7 +683,6 @@ figure blockquote p {
     margin: 0;
     padding: 12px 25px;
     text-decoration: none;
-    text-transform: capitalize;
 }
 
 .btn-primary table td {

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

@@ -0,0 +1,57 @@
+/**
+ * @typedef {import('./oembed').ICustomProvider} ICustomProvider
+ * @typedef {import('./oembed').IExternalRequest} IExternalRequest
+ */
+
+const OPENSEA_PATH_REGEX = /^\/assets\/(0x[a-f0-9]+)\/(\d+)/;
+
+/**
+ * @implements ICustomProvider
+ */
+class NFTOEmbedProvider {
+    /**
+     * @param {object} dependencies
+     */
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+
+    /**
+     * @param {URL} url
+     * @returns {Promise<boolean>}
+     */
+    async canSupportRequest(url) {
+        return url.host === 'opensea.io' && OPENSEA_PATH_REGEX.test(url.pathname);
+    }
+
+    /**
+     * @param {URL} url
+     * @param {IExternalRequest} externalRequest
+     *
+     * @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}/?format=json`, {
+            json: true
+        });
+        return {
+            version: '1.0',
+            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',
+            image_url: result.body.image_url,
+            creator_name: result.body.creator.user.username,
+            description: result.body.description,
+            collection_name: result.body.collection.name
+        };
+    }
+}
+
+module.exports = NFTOEmbedProvider;