ghost 4.22.2 → 4.24.0

package/core/server/services/oembed.js

@@ -1,5 +1,6 @@
 const errors = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
+const logging = require('@tryghost/logging');
 const {extract, hasProvider} = require('oembed-parser');
 const cheerio = require('cheerio');
 const _ = require('lodash');
@@ -62,6 +63,7 @@ class OEmbed {
      */
     constructor({config, externalRequest}) {
         this.config = config;
+
         /** @type {IExternalRequest} */
         this.externalRequest = async (url, requestConfig) => {
             if (this.isIpOrLocalhost(url)) {
@@ -73,6 +75,7 @@ class OEmbed {
             }
             return response;
         };
+
         /** @type {ICustomProvider[]} */
         this.customProviders = [];
     }
@@ -107,24 +110,6 @@ class OEmbed {
         }
     }
 
-    /**
-     * @param {string} url
-     */
-    errorHandler(url) {
-        /**
-         * @param {Error|errors.GhostError} err
-         */
-        return async (err) => {
-            // allow specific validation errors through for better error messages
-            if (errors.utils.isIgnitionError(err) && err.errorType === 'ValidationError') {
-                throw err;
-            }
-
-            // default to unknown provider to avoid leaking any app specifics
-            return this.unknownProvider(url);
-        };
-    }
-
     async fetchBookmarkData(url) {
         const metascraper = require('metascraper')([
             require('metascraper-url')(),
@@ -296,10 +281,9 @@ class OEmbed {
      * @returns {Promise<Object>}
      */
     async fetchOembedDataFromUrl(url, type) {
-        let data;
-
         try {
             const urlObject = new URL(url);
+
             for (const provider of this.customProviders) {
                 if (await provider.canSupportRequest(urlObject)) {
                     const result = await provider.getOEmbedData(urlObject, this.externalRequest);
@@ -309,23 +293,39 @@ class OEmbed {
                 }
             }
 
+            // fetch only bookmark when explicitly requested
             if (type === 'bookmark') {
                 return this.fetchBookmarkData(url);
             }
 
-            data = await this.fetchOembedData(url);
+            // attempt to fetch oembed
+            let data = await this.fetchOembedData(url);
 
+            // fallback to bookmark when we can't get oembed
             if (!data && !type) {
                 data = await this.fetchBookmarkData(url);
             }
 
+            // couldn't get anything, throw a validation error
             if (!data) {
-                data = await this.unknownProvider(url);
+                return this.unknownProvider(url);
             }
 
             return data;
-        } catch (e) {
-            return this.errorHandler(url);
+        } catch (err) {
+            // allow specific validation errors through for better error messages
+            if (errors.utils.isIgnitionError(err) && err.errorType === 'ValidationError') {
+                throw err;
+            }
+
+            // log the real error because we're going to throw a generic "Unknown provider" error
+            logging.error(new errors.GhostError({
+                message: 'Encountered error when fetching oembed',
+                err
+            }));
+
+            // default to unknown provider to avoid leaking any app specifics
+            return this.unknownProvider(url);
         }
     }
 }

package/core/server/services/public-config/config.js

@@ -17,7 +17,7 @@ module.exports = function getConfigProperties() {
         mailgunIsConfigured: config.get('bulkEmail') && config.get('bulkEmail').mailgun,
         emailAnalytics: config.get('emailAnalytics'),
         hostSettings: config.get('hostSettings'),
-        tenorApiKey: config.get('tenorApiKey')
+        tenor: config.get('tenor')
     };
 
     const billingUrl = config.get('hostSettings:billing:enabled') ? config.get('hostSettings:billing:url') : '';

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

@@ -1,14 +1,11 @@
 const fs = require('fs-extra');
 const path = require('path');
-const moment = require('moment-timezone');
 const yaml = require('js-yaml');
 
 const logging = require('@tryghost/logging');
 const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
 
-const validation = require('./validation');
-
 const messages = {
     jsonParse: 'Could not parse JSON: {context}.',
     yamlParse: 'Could not parse YAML: {context}.',
@@ -22,7 +19,7 @@ const messages = {
  * @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
+ * @property {boolean} [permanent] - Can be defined with true for a permanent HTTP 301 redirect, or false for a temporary HTTP 302 redirect
  */
 
 /**
@@ -120,16 +117,6 @@ const parseRedirectsFile = (content, ext) => {
     throw new errors.IncorrectUsageError();
 };
 
-/**
- * @param {string} filePath
- * @returns {string}
- */
-const getBackupRedirectsFilePath = (filePath) => {
-    const {dir, name, ext} = path.parse(filePath);
-
-    return path.join(dir, `${name}-${moment().format('YYYY-MM-DD-HH-mm-ss')}${ext}`);
-};
-
 /**
  * @typedef {object} IRedirectManager
  */
@@ -138,14 +125,22 @@ class CustomRedirectsAPI {
     /**
      * @param {object} config
      * @param {string} config.basePath
-     *
-     * @param {IRedirectManager} redirectManager
+     * @param {Function} config.validate - validates redirects configuration
+     * @param {Function} config.getBackupFilePath
+     * @param {IRedirectManager} config.redirectManager
      */
-    constructor(config, redirectManager) {
+    constructor({basePath, validate, redirectManager, getBackupFilePath}) {
         /** @private */
-        this.config = config;
+        this.basePath = basePath;
+
         /** @private */
         this.redirectManager = redirectManager;
+
+        /** @private */
+        this.validate = validate;
+
+        /** @private */
+        this.getBackupFilePath = getBackupFilePath;
     }
 
     async init() {
@@ -159,7 +154,7 @@ class CustomRedirectsAPI {
                 const content = await readRedirectsFile(filePath);
                 const ext = path.extname(filePath);
                 const redirects = parseRedirectsFile(content, ext);
-                validation.validate(redirects);
+                this.validate(redirects);
 
                 this.redirectManager.removeAllRedirects();
                 for (const redirect of redirects) {
@@ -187,7 +182,7 @@ class CustomRedirectsAPI {
      * @returns {string}
      */
     createRedirectsFilePath(ext) {
-        return path.join(this.config.basePath, `redirects${ext}`);
+        return path.join(this.basePath, `redirects${ext}`);
     }
 
     /**
@@ -222,7 +217,7 @@ class CustomRedirectsAPI {
         const redirectsFilePath = await this.getRedirectsFilePath();
 
         if (redirectsFilePath) {
-            const backupRedirectsPath = getBackupRedirectsFilePath(redirectsFilePath);
+            const backupRedirectsPath = this.getBackupFilePath(redirectsFilePath);
 
             const backupExists = await fs.pathExists(backupRedirectsPath);
             if (backupExists) {
@@ -234,10 +229,10 @@ class CustomRedirectsAPI {
 
         const content = await readRedirectsFile(filePath);
         const parsed = parseRedirectsFile(content, ext);
-        validation.validate(parsed);
+        this.validate(parsed);
 
         if (ext === '.json') {
-            await fs.writeFile(this.createRedirectsFilePath('.json'), JSON.stringify(content), 'utf-8');
+            await fs.writeFile(this.createRedirectsFilePath('.json'), JSON.stringify(parsed), 'utf-8');
         } else if (ext === '.yaml') {
             await fs.copy(filePath, this.createRedirectsFilePath('.yaml'));
         }

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

@@ -3,21 +3,27 @@ const urlUtils = require('../../../shared/url-utils');
 
 const DynamicRedirectManager = require('@tryghost/express-dynamic-redirects');
 const CustomRedirectsAPI = require('./api');
-
-const redirectManager = new DynamicRedirectManager({
-    permanentMaxAge: config.get('caching:customRedirects:maxAge'),
-    getSubdirectoryURL: (pathname) => {
-        return urlUtils.urlJoin(urlUtils.getSubdir(), pathname);
-    }
-});
+const validation = require('./validation');
+const {getBackupRedirectsFilePath} = require('./utils');
 
 let customRedirectsAPI;
+let redirectManager;
 
 module.exports = {
     init() {
+        redirectManager = new DynamicRedirectManager({
+            permanentMaxAge: config.get('caching:customRedirects:maxAge'),
+            getSubdirectoryURL: (pathname) => {
+                return urlUtils.urlJoin(urlUtils.getSubdir(), pathname);
+            }
+        });
+
         customRedirectsAPI = new CustomRedirectsAPI({
-            basePath: config.getContentPath('data')
-        }, redirectManager);
+            basePath: config.getContentPath('data'),
+            redirectManager,
+            getBackupFilePath: getBackupRedirectsFilePath,
+            validate: validation.validate.bind(validation)
+        });
 
         return customRedirectsAPI.init();
     },
@@ -26,5 +32,7 @@ module.exports = {
         return customRedirectsAPI;
     },
 
-    middleware: redirectManager.handleRequest
+    get middleware() {
+        return redirectManager.handleRequest;
+    }
 };

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

@@ -0,0 +1,14 @@
+const path = require('path');
+const moment = require('moment-timezone');
+
+/**
+ * @param {string} filePath
+ * @returns {string}
+ */
+const getBackupRedirectsFilePath = (filePath) => {
+    const {dir, name, ext} = path.parse(filePath);
+
+    return path.join(dir, `${name}-${moment().format('YYYY-MM-DD-HH-mm-ss')}${ext}`);
+};
+
+module.exports.getBackupRedirectsFilePath = getBackupRedirectsFilePath;

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/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,19 +1,12 @@
 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.'
@@ -31,134 +24,154 @@ 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';
+        /**
+         * @private
+         */
+        this.filename = 'routes';
+        /**
+         * @private
+         */
+        this.ext = 'yaml';
+
+        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.isIgnitionError(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 {
+            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, {filename: `${this.filename}.${this.ext}`})
+                            });
+                        }
+
+                        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;