ghost 4.23.0 → 4.26.0

package/core/server/services/redirects/validation.js

@@ -7,9 +7,19 @@ const messages = {
     invalidRedirectsFromRegex: 'Incorrect RegEx in redirects file.',
     redirectsHelp: 'https://ghost.org/docs/themes/routing/#redirects'
 };
+
+/**
+ * Redirect configuration object
+ * @typedef {Object} RedirectConfig
+ * @property {String} from - Defines the relative incoming URL or pattern (regex)
+ * @property {String} to - Defines where the incoming traffic should be redirected to, which can be a static URL, or a dynamic value using regex (example: "to": "/$1/")
+ * @property {boolean} [permanent] - Can be defined with true for a permanent HTTP 301 redirect, or false for a temporary HTTP 302 redirect
+ */
+
 /**
  * Redirects are file based at the moment, but they will live in the database in the future.
  * See V2 of https://github.com/TryGhost/Ghost/issues/7707.
+ * @param {RedirectConfig[]} redirects
  */
 const validate = (redirects) => {
     if (!_.isArray(redirects)) {

package/core/server/services/route-settings/default-settings-manager.js

@@ -48,7 +48,7 @@ class DefaultSettingsManager {
                 });
             }).catch((error) => {
                 // CASE: we might have a permission error, as we can't access the directory
-                throw new errors.GhostError({
+                throw new errors.InternalServerError({
                     message: tpl(messages.ensureSettings, {
                         path: this.destinationFolderPath
                     }),

package/core/server/services/route-settings/index.js

@@ -1,32 +1,55 @@
-const routeSettings = require('./route-settings');
-const SettingsLoader = require('./settings-loader');
 const config = require('../../../shared/config');
 const parseYaml = require('./yaml-parser');
-const DefaultSettingsManager = require('./default-settings-manager');
+const SettingsPathManager = require('@tryghost/settings-path-manager');
 
-const defaultSettingsManager = new DefaultSettingsManager({
-    type: 'routes',
-    extension: '.yaml',
-    destinationFolderPath: config.getContentPath('settings'),
-    sourceFolderPath: config.get('paths').defaultSettings
-});
-
-const settingsLoader = new SettingsLoader({parseYaml});
+let settingsLoader;
+let routeSettings;
 
 module.exports = {
     init: async () => {
+        const RouteSettings = require('./route-settings');
+        const SettingsLoader = require('./settings-loader');
+        const DefaultSettingsManager = require('./default-settings-manager');
+
+        const settingsPathManager = new SettingsPathManager({type: 'routes', paths: [config.getContentPath('settings')]});
+        settingsLoader = new SettingsLoader({parseYaml, settingFilePath: settingsPathManager.getDefaultFilePath()});
+        routeSettings = new RouteSettings({
+            settingsLoader,
+            settingsPath: settingsPathManager.getDefaultFilePath(),
+            backupPath: settingsPathManager.getBackupFilePath()
+        });
+        const defaultSettingsManager = new DefaultSettingsManager({
+            type: 'routes',
+            extension: '.yaml',
+            destinationFolderPath: config.getContentPath('settings'),
+            sourceFolderPath: config.get('paths').defaultSettings
+        });
+
         return await defaultSettingsManager.ensureSettingsFileExists();
     },
 
-    loadRouteSettingsSync: settingsLoader.loadSettingsSync.bind(settingsLoader),
-    loadRouteSettings: settingsLoader.loadSettings.bind(settingsLoader),
-    getDefaultHash: routeSettings.getDefaultHash,
+    get loadRouteSettingsSync() {
+        return settingsLoader.loadSettingsSync.bind(settingsLoader);
+    },
+    get loadRouteSettings() {
+        return settingsLoader.loadSettings.bind(settingsLoader);
+    },
+    get getDefaultHash() {
+        return routeSettings.getDefaultHash.bind(routeSettings);
+    },
+
     /**
      * Methods used in the API
      */
     api: {
-        setFromFilePath: routeSettings.setFromFilePath,
-        get: routeSettings.get,
-        getCurrentHash: routeSettings.getCurrentHash
+        get setFromFilePath() {
+            return routeSettings.setFromFilePath.bind(routeSettings);
+        },
+        get get() {
+            return routeSettings.get.bind(routeSettings);
+        },
+        get getCurrentHash() {
+            return routeSettings.getCurrentHash.bind(routeSettings);
+        }
     }
 };

package/core/server/services/route-settings/route-settings.js

@@ -1,22 +1,15 @@
 const Promise = require('bluebird');
-const moment = require('moment-timezone');
 const fs = require('fs-extra');
-const path = require('path');
 const crypto = require('crypto');
 const urlService = require('../url');
 
 const debug = require('@tryghost/debug')('services:route-settings');
 const errors = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
-const config = require('../../../shared/config');
 const bridge = require('../../../bridge');
-const SettingsLoader = require('./settings-loader');
-const parseYaml = require('./yaml-parser');
-
-const settingsLoader = new SettingsLoader({parseYaml});
 
 const messages = {
-    loadError: 'Could not load {filename} file.'
+    loadError: 'Could not load routes.yaml file.'
 };
 
 /**
@@ -31,134 +24,146 @@ const messages = {
  * - then we reload the whole site app, which will reset all routers and re-create the url generators
  */
 
-const filename = 'routes';
-const ext = 'yaml';
-
-const getSettingsFilePath = () => {
-    const settingsFolder = config.getContentPath('settings');
-    return path.join(settingsFolder, `${filename}.${ext}`);
-};
-
-const getBackupFilePath = () => {
-    const settingsFolder = config.getContentPath('settings');
-    return path.join(settingsFolder, `${filename}-${moment().format('YYYY-MM-DD-HH-mm-ss')}.${ext}`);
-};
+class RouteSettings {
+    /**
+     *
+     * @param {Object} options
+     * @param {Object} options.settingsLoader
+     * @param {String} options.settingsPath
+     * @param {String} options.backupPath
+     */
+    constructor({settingsLoader, settingsPath, backupPath}) {
+        /**
+         * md5 hashes of default routes settings
+         * @private
+         */
+        this.defaultRoutesSettingHash = '3d180d52c663d173a6be791ef411ed01';
+
+        this.settingsLoader = settingsLoader;
+        this.settingsPath = settingsPath;
+        this.backupPath = backupPath;
+    }
 
-const createBackupFile = async (settingsPath, backupPath) => {
-    return await fs.copy(settingsPath, backupPath);
-};
+    /**
+     * @private
+     * @param {String} settingsPath
+     * @param {String} backupPath
+     */
+    async createBackupFile(settingsPath, backupPath) {
+        return await fs.copy(settingsPath, backupPath);
+    }
 
-const restoreBackupFile = async (settingsPath, backupPath) => {
-    return await fs.copy(backupPath, settingsPath);
-};
+    /**
+     * @private
+     * @param {String} settingsPath
+     * @param {String} backupPath
+     */
+    async restoreBackupFile(settingsPath, backupPath) {
+        return await fs.copy(backupPath, settingsPath);
+    }
 
-const saveFile = async (filePath, settingsPath) => {
-    return await fs.copy(filePath, settingsPath);
-};
+    /**
+     * @private
+     * @param {String} filePath
+     * @param {String} settingsPath
+     */
+    async saveFile(filePath, settingsPath) {
+        return await fs.copy(filePath, settingsPath);
+    }
 
-const readFile = (settingsFilePath) => {
-    return fs.readFile(settingsFilePath, 'utf-8')
-        .catch((err) => {
-            if (err.code === 'ENOENT') {
-                return Promise.resolve([]);
-            }
+    /**
+     * @private
+     * @param {String} settingsFilePath
+     */
+    async readFile(settingsFilePath) {
+        return fs.readFile(settingsFilePath, 'utf-8')
+            .catch((err) => {
+                if (err.code === 'ENOENT') {
+                    return Promise.resolve([]);
+                }
 
-            if (errors.utils.isIgnitionError(err)) {
-                throw err;
-            }
+                if (errors.utils.isGhostError(err)) {
+                    throw err;
+                }
 
-            throw new errors.NotFoundError({
-                err: err
+                throw new errors.NotFoundError({
+                    err: err
+                });
             });
-        });
-};
-
-const setFromFilePath = async (filePath) => {
-    const settingsPath = getSettingsFilePath();
-    const backupPath = getBackupFilePath();
-
-    await createBackupFile(settingsPath, backupPath);
-    await saveFile(filePath, settingsPath);
+    }
 
-    urlService.resetGenerators({releaseResourcesOnly: true});
+    async setFromFilePath(filePath) {
+        await this.createBackupFile(this.settingsPath, this.backupPath);
+        await this.saveFile(filePath, this.settingsPath);
 
-    const bringBackValidRoutes = async () => {
         urlService.resetGenerators({releaseResourcesOnly: true});
 
-        await restoreBackupFile(settingsPath, backupPath);
-
-        return bridge.reloadFrontend();
-    };
-
-    try {
-        bridge.reloadFrontend();
-    } catch (err) {
-        return bringBackValidRoutes()
-            .finally(() => {
-                throw err;
-            });
-    }
+        const bringBackValidRoutes = async () => {
+            urlService.resetGenerators({releaseResourcesOnly: true});
 
-    // @TODO: how can we get rid of this from here?
-    let tries = 0;
-
-    function isBlogRunning() {
-        debug('waiting for blog running');
-        return Promise.delay(1000)
-            .then(() => {
-                debug('waited for blog running');
-                if (!urlService.hasFinished()) {
-                    if (tries > 5) {
-                        throw new errors.InternalServerError({
-                            message: tpl(messages.loadError, {filename: `${filename}.${ext}`})
-                        });
-                    }
+            await this.restoreBackupFile(this.settingsPath, this.backupPath);
 
-                    tries = tries + 1;
-                    return isBlogRunning();
-                }
-            });
-    }
+            return bridge.reloadFrontend();
+        };
 
-    return isBlogRunning()
-        .catch((err) => {
+        try {
+            await bridge.reloadFrontend();
+        } catch (err) {
             return bringBackValidRoutes()
                 .finally(() => {
                     throw err;
                 });
-        });
-};
-
-const get = async () => {
-    const settingsFilePath = await getSettingsFilePath();
-
-    return readFile(settingsFilePath);
-};
+        }
+
+        // @TODO: how can we get rid of this from here?
+        let tries = 0;
+
+        function isBlogRunning() {
+            debug('waiting for blog running');
+            return Promise.delay(1000)
+                .then(() => {
+                    debug('waited for blog running');
+                    if (!urlService.hasFinished()) {
+                        if (tries > 5) {
+                            throw new errors.InternalServerError({
+                                message: tpl(messages.loadError)
+                            });
+                        }
+
+                        tries = tries + 1;
+                        return isBlogRunning();
+                    }
+                });
+        }
+
+        return isBlogRunning()
+            .catch((err) => {
+                return bringBackValidRoutes()
+                    .finally(() => {
+                        throw err;
+                    });
+            });
+    }
 
-/**
- * md5 hashes of default routes settings
- */
-const defaultRoutesSettingHash = '3d180d52c663d173a6be791ef411ed01';
+    async get() {
+        return this.readFile(this.settingsPath);
+    }
 
-const calculateHash = (data) => {
-    return crypto.createHash('md5')
-        .update(data, 'binary')
-        .digest('hex');
-};
+    calculateHash(data) {
+        return crypto.createHash('md5')
+            .update(data, 'binary')
+            .digest('hex');
+    }
 
-const getDefaultHash = () => {
-    return defaultRoutesSettingHash;
-};
+    getDefaultHash() {
+        return this.defaultRoutesSettingHash;
+    }
 
-const getCurrentHash = async () => {
-    const data = await settingsLoader.loadSettings();
+    async getCurrentHash() {
+        const data = await this.settingsLoader.loadSettings();
 
-    return calculateHash(JSON.stringify(data));
-};
+        return this.calculateHash(JSON.stringify(data));
+    }
+}
 
-module.exports = {
-    getDefaultHash: getDefaultHash,
-    setFromFilePath: setFromFilePath,
-    get: get,
-    getCurrentHash: getCurrentHash
-};
+module.exports = RouteSettings;

package/core/server/services/route-settings/settings-loader.js

@@ -1,9 +1,7 @@
 const fs = require('fs-extra');
-const path = require('path');
 const debug = require('@tryghost/debug')('frontend:services:settings:settings-loader');
 const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
-const config = require('../../../shared/config');
 const validate = require('./validate');
 
 const messages = {
@@ -14,23 +12,12 @@ class SettingsLoader {
     /**
      * @param {Object} options
      * @param {Function} options.parseYaml yaml parser
+     * @param {String} options.settingFilePath routes settings file path
      */
-    constructor({parseYaml}) {
+    constructor({parseYaml, settingFilePath}) {
         this.parseYaml = parseYaml;
-    }
-
-    /**
-     * NOTE: this method will have to go to an external module to reuse in redirects settings
-     * @param {String} setting type of the settings to load, e.g:'routes' or 'redirects'
-     * @returns {String} setting file path
-     */
-    getSettingFilePath(setting) {
-        // we only support the `yaml` file extension. `yml` will be ignored.
-        const fileName = `${setting}.yaml`;
-        const contentPath = config.getContentPath('settings');
-        const filePath = path.join(contentPath, fileName);
 
-        return filePath;
+        this.settingFilePath = settingFilePath;
     }
 
     /**
@@ -40,27 +27,23 @@ class SettingsLoader {
      * @returns {Promise<Object>} settingsFile
      */
     async loadSettings() {
-        const setting = 'routes';
-        const filePath = this.getSettingFilePath(setting);
-
         try {
-            const file = await fs.readFile(filePath, 'utf8');
-            debug('settings file found for', setting);
+            const file = await fs.readFile(this.settingFilePath, 'utf8');
+            debug('routes settings file found for:', this.settingFilePath);
 
             const object = this.parseYaml(file);
-
-            debug('YAML settings file parsed:', filePath);
+            debug('YAML settings file parsed:', this.settingFilePath);
 
             return validate(object);
         } catch (err) {
-            if (errors.utils.isIgnitionError(err)) {
+            if (errors.utils.isGhostError(err)) {
                 throw err;
             }
 
-            throw new errors.GhostError({
+            throw new errors.InternalServerError({
                 message: tpl(messages.settingsLoaderError, {
-                    setting: setting,
-                    path: filePath
+                    setting: 'routes',
+                    path: this.settingFilePath
                 }),
                 err: err
             });
@@ -74,24 +57,23 @@ class SettingsLoader {
      * @returns {Object} settingsFile in following format: {routes: {}, collections: {}, resources: {}}
      */
     loadSettingsSync() {
-        const setting = 'routes';
-        const filePath = this.getSettingFilePath(setting);
-
         try {
-            const file = fs.readFileSync(filePath, 'utf8');
-            debug('settings file found for', setting);
+            const file = fs.readFileSync(this.settingFilePath, 'utf8');
+            debug('routes settings file found for:', this.settingFilePath);
 
             const object = this.parseYaml(file);
+            debug('YAML settings file parsed:', this.settingFilePath);
+
             return validate(object);
         } catch (err) {
-            if (errors.utils.isIgnitionError(err)) {
+            if (errors.utils.isGhostError(err)) {
                 throw err;
             }
 
-            throw new errors.GhostError({
+            throw new errors.InternalServerError({
                 message: tpl(messages.settingsLoaderError, {
-                    setting: setting,
-                    path: filePath
+                    setting: 'routes',
+                    path: this.settingFilePath
                 }),
                 err: err
             });

package/core/server/services/route-settings/yaml-parser.js

@@ -35,7 +35,7 @@ module.exports = function parseYaml(file) {
 
         return parsed;
     } catch (error) {
-        if (errors.utils.isIgnitionError(error)) {
+        if (errors.utils.isGhostError(error)) {
             throw error;
         }
 

package/core/server/services/slack.js

@@ -136,7 +136,7 @@ function ping(post) {
                 'Content-type': 'application/json'
             }
         }).catch(function (err) {
-            logging.error(new errors.GhostError({
+            logging.error(new errors.InternalServerError({
                 err: err,
                 context: tpl(messages.requestFailedError, {service: 'slack'}),
                 help: tpl(messages.requestFailedHelp, {url: 'https://ghost.org/docs/'})

package/core/server/services/themes/activation-bridge.js

@@ -14,7 +14,7 @@ module.exports = {
         if (labs.isSet('customThemeSettings')) {
             await customThemeSettings.api.activateTheme(themeName, checkedTheme);
         }
-        bridge.activateTheme(theme, checkedTheme);
+        await bridge.activateTheme(theme, checkedTheme);
     },
     activateFromAPI: async (themeName, theme, checkedTheme) => {
         debug('Activating theme (method B on API "activate")', themeName);
@@ -22,7 +22,7 @@ module.exports = {
         if (labs.isSet('customThemeSettings')) {
             await customThemeSettings.api.activateTheme(themeName, checkedTheme);
         }
-        bridge.activateTheme(theme, checkedTheme);
+        await bridge.activateTheme(theme, checkedTheme);
     },
     activateFromAPIOverride: async (themeName, theme, checkedTheme) => {
         debug('Activating theme (method C on API "override")', themeName);
@@ -30,6 +30,6 @@ module.exports = {
         if (labs.isSet('customThemeSettings')) {
             await customThemeSettings.api.activateTheme(themeName, checkedTheme);
         }
-        bridge.activateTheme(theme, checkedTheme);
+        await bridge.activateTheme(theme, checkedTheme);
     }
 };

package/core/server/services/themes/storage.js

@@ -112,7 +112,7 @@ module.exports = {
             if (checkedTheme) {
                 fs.remove(checkedTheme.path)
                     .catch((err) => {
-                        logging.error(new errors.GhostError({err: err}));
+                        logging.error(new errors.InternalServerError({err: err}));
                     });
             }
 
@@ -120,7 +120,7 @@ module.exports = {
             getStorage()
                 .delete(backupName)
                 .catch((err) => {
-                    logging.error(new errors.GhostError({err: err}));
+                    logging.error(new errors.InternalServerError({err: err}));
                 });
         }
     },

package/core/server/services/twitter-embed.js

@@ -0,0 +1,81 @@
+const {extract} = require('oembed-parser');
+
+/**
+ * @typedef {import('./oembed').ICustomProvider} ICustomProvider
+ * @typedef {import('./oembed').IExternalRequest} IExternalRequest
+ */
+
+const TWITTER_PATH_REGEX = /\/status\/(\d+)/;
+
+/**
+ * @implements ICustomProvider
+ */
+class TwitterOEmbedProvider {
+    /**
+     * @param {object} dependencies
+     */
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+
+    /**
+     * @param {URL} url
+     * @returns {Promise<boolean>}
+     */
+    async canSupportRequest(url) {
+        return url.host === 'twitter.com' && TWITTER_PATH_REGEX.test(url.pathname);
+    }
+
+    /**
+     * @param {URL} url
+     * @param {IExternalRequest} externalRequest
+     *
+     * @returns {Promise<object>}
+     */
+    async getOEmbedData(url, externalRequest) {
+        const [match, tweetId] = url.pathname.match(TWITTER_PATH_REGEX);
+        if (!match) {
+            return null;
+        }
+
+        /** @type {object} */
+        const oembedData = await extract(url.href);
+
+        if (this.dependencies.config.bearerToken) {
+            const query = {
+                expansions: ['attachments.poll_ids', 'attachments.media_keys', 'author_id', 'entities.mentions.username', 'geo.place_id', 'in_reply_to_user_id', 'referenced_tweets.id', 'referenced_tweets.id.author_id'],
+                'media.fields': ['duration_ms', 'height', 'media_key', 'preview_image_url', 'type', 'url', 'width', 'public_metrics', 'alt_text'],
+                'place.fields': ['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type'],
+                'poll.fields': ['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status'],
+                'tweet.fields': ['attachments', 'author_id', 'context_annotations', 'conversation_id', 'created_at', 'entities', 'geo', 'id', 'in_reply_to_user_id', 'lang', 'public_metrics', 'possibly_sensitive', 'referenced_tweets', 'reply_settings', 'source', 'text', 'withheld'],
+                'user.fields': ['created_at', 'description', 'entities', 'id', 'location', 'name', 'pinned_tweet_id', 'profile_image_url', 'protected', 'public_metrics', 'url', 'username', 'verified', 'withheld']
+            };
+
+            const queryString = Object.keys(query).map((key) => {
+                return `${key}=${query[key].join(',')}`;
+            }).join('&');
+
+            try {
+                const result = await externalRequest(`https://api.twitter.com/2/tweets/${tweetId}?${queryString}`, {
+                    responseType: 'json',
+                    headers: {
+                        Authorization: `Bearer ${this.dependencies.config.bearerToken}`
+                    }
+                });
+
+                const body = JSON.parse(result.body);
+
+                oembedData.tweet_data = body.data;
+                oembedData.tweet_data.includes = body.includes;
+            } catch (err) {
+                this.dependencies.logging.error(err);
+            }
+        }
+
+        oembedData.type = 'twitter';
+
+        return oembedData;
+    }
+}
+
+module.exports = TwitterOEmbedProvider;