ghost 4.22.3 → 4.25.0

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
  */
 
 /**
@@ -37,7 +34,7 @@ const readRedirectsFile = async (redirectsPath) => {
             return '';
         }
 
-        if (errors.utils.isIgnitionError(err)) {
+        if (errors.utils.isGhostError(err)) {
             throw err;
         }
 
@@ -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) {
@@ -167,7 +162,7 @@ class CustomRedirectsAPI {
                 }
             }
         } catch (err) {
-            if (errors.utils.isIgnitionError(err)) {
+            if (errors.utils.isGhostError(err)) {
                 logging.error(err);
             } else {
                 logging.error(new errors.IncorrectUsageError({
@@ -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/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
             });