ghost 4.15.0 → 4.17.1

package/core/{frontend → server}/services/redirects/settings.js

@@ -3,12 +3,19 @@ const path = require('path');
 const moment = require('moment-timezone');
 const yaml = require('js-yaml');
 const Promise = require('bluebird');
-const validation = require('./validation');
 
-const config = require('../../../shared/config');
-const i18n = require('../../../shared/i18n');
+const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
 
+const validation = require('./validation');
+const config = require('../../../shared/config');
+
+const messages = {
+    jsonParse: 'Could not parse JSON: {context}.',
+    yamlParse: 'YAML input cannot be a plain string. Check the format of your YAML file.',
+    yamlParseHelp: 'https://ghost.org/docs/themes/routing/#redirects'
+};
+
 /**
  * Redirect configuration object
  * @typedef {Object} RedirectConfig
@@ -49,7 +56,7 @@ const parseRedirectsFile = (content, ext) => {
             redirects = JSON.parse(content);
         } catch (err) {
             throw new errors.BadRequestError({
-                message: i18n.t('errors.general.jsonParse', {context: err.message})
+                message: tpl(messages.jsonParse, {context: err.message})
             });
         }
 
@@ -66,8 +73,8 @@ const parseRedirectsFile = (content, ext) => {
         // Here we check if the user made this mistake.
         if (typeof configYaml === 'string') {
             throw new errors.BadRequestError({
-                message: i18n.t('errors.api.redirects.yamlParse'),
-                help: 'https://ghost.org/docs/themes/routing/#redirects'
+                message: tpl(messages.yamlParse),
+                help: tpl(messages.yamlParseHelp)
             });
         }
 

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

@@ -0,0 +1,44 @@
+const _ = require('lodash');
+const tpl = require('@tryghost/tpl');
+const errors = require('@tryghost/errors');
+
+const messages = {
+    redirectsWrongFormat: 'Incorrect redirects file format.',
+    invalidRedirectsFromRegex: 'Incorrect RegEx in redirects file.',
+    redirectsHelp: 'https://ghost.org/docs/themes/routing/#redirects'
+};
+/**
+ * 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.
+ */
+const validate = (redirects) => {
+    if (!_.isArray(redirects)) {
+        throw new errors.ValidationError({
+            message: tpl(messages.redirectsWrongFormat),
+            help: tpl(messages.redirectsHelp)
+        });
+    }
+
+    _.each(redirects, function (redirect) {
+        if (!redirect.from || !redirect.to) {
+            throw new errors.ValidationError({
+                message: tpl(messages.redirectsWrongFormat),
+                context: redirect,
+                help: tpl(messages.redirectsHelp)
+            });
+        }
+
+        try {
+            // each 'from' property should be a valid RegExp string
+            new RegExp(redirect.from);
+        } catch (error) {
+            throw new errors.ValidationError({
+                message: tpl(messages.invalidRedirectsFromRegex),
+                context: redirect,
+                help: tpl(messages.redirectsHelp)
+            });
+        }
+    });
+};
+
+module.exports.validate = validate;

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

@@ -0,0 +1,62 @@
+const fs = require('fs-extra');
+const Promise = require('bluebird');
+const path = require('path');
+const debug = require('@tryghost/debug')('frontend:services:settings:ensure-settings');
+const tpl = require('@tryghost/tpl');
+const errors = require('@tryghost/errors');
+
+const messages = {
+    ensureSettings: 'Error trying to access settings files in {path}.'
+};
+
+class DefaultSettingsManager {
+    /**
+     *
+     * @param {Object} options
+     * @param {String} options.type - name of the setting file
+     * @param {String} options.extension - settings file extension
+     * @param {String} options.destinationFolderPath - path to store the default setting config
+     * @param {String} options.sourceFolderPath - path where the default config can be seeded from
+     */
+    constructor({type, extension, destinationFolderPath, sourceFolderPath}) {
+        this.type = type;
+        this.extension = extension;
+        this.destinationFolderPath = destinationFolderPath;
+        this.sourceFolderPath = sourceFolderPath;
+    }
+
+    /**
+     *
+     * Makes sure the destination folder either contains a file or copies over a default file.
+     * @returns {Promise<any>}
+     */
+    async ensureSettingsFileExists() {
+        const fileName = this.type + this.extension;
+        const defaultFileName = `default-${fileName}`;
+
+        const destinationFilePath = path.join(this.destinationFolderPath, fileName);
+        const defaultFilePath = path.join(this.sourceFolderPath, defaultFileName);
+
+        return Promise.resolve(fs.readFile(destinationFilePath, 'utf8'))
+            .catch({code: 'ENOENT'}, () => {
+                // CASE: file doesn't exist, copy it from our defaults
+                return fs.copy(
+                    defaultFilePath,
+                    destinationFilePath
+                ).then(() => {
+                    debug(`'${defaultFileName}' copied to ${this.destinationFolderPath}.`);
+                });
+            }).catch((error) => {
+                // CASE: we might have a permission error, as we can't access the directory
+                throw new errors.GhostError({
+                    message: tpl(messages.ensureSettings, {
+                        path: this.destinationFolderPath
+                    }),
+                    err: error,
+                    context: error.path
+                });
+            });
+    }
+}
+
+module.exports = DefaultSettingsManager;

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

@@ -1 +1,32 @@
-module.exports = require('./route-settings');
+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 defaultSettingsManager = new DefaultSettingsManager({
+    type: 'routes',
+    extension: '.yaml',
+    destinationFolderPath: config.getContentPath('settings'),
+    sourceFolderPath: config.get('paths').defaultSettings
+});
+
+const settingsLoader = new SettingsLoader({parseYaml});
+
+module.exports = {
+    init: async () => {
+        return await defaultSettingsManager.ensureSettingsFileExists();
+    },
+
+    loadRouteSettingsSync: settingsLoader.loadSettingsSync.bind(settingsLoader),
+    loadRouteSettings: settingsLoader.loadSettings.bind(settingsLoader),
+    getDefaultHash: routeSettings.getDefaultHash,
+    /**
+     * Methods used in the API
+     */
+    api: {
+        setFromFilePath: routeSettings.setFromFilePath,
+        get: routeSettings.get,
+        getCurrentHash: routeSettings.getCurrentHash
+    }
+};

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

@@ -2,6 +2,7 @@ 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('../../../frontend/services/url');
 
 const debug = require('@tryghost/debug')('services:route-settings');
@@ -9,6 +10,10 @@ 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.'
@@ -29,17 +34,13 @@ const messages = {
 const filename = 'routes';
 const ext = 'yaml';
 
-const getSettingsFolder = async () => {
-    return config.getContentPath('settings');
-};
-
-const getSettingsFilePath = async () => {
-    const settingsFolder = await getSettingsFolder();
+const getSettingsFilePath = () => {
+    const settingsFolder = config.getContentPath('settings');
     return path.join(settingsFolder, `${filename}.${ext}`);
 };
 
-const getBackupFilePath = async () => {
-    const settingsFolder = await getSettingsFolder();
+const getBackupFilePath = () => {
+    const settingsFolder = config.getContentPath('settings');
     return path.join(settingsFolder, `${filename}-${moment().format('YYYY-MM-DD-HH-mm-ss')}.${ext}`);
 };
 
@@ -73,8 +74,8 @@ const readFile = (settingsFilePath) => {
 };
 
 const setFromFilePath = async (filePath) => {
-    const settingsPath = await getSettingsFilePath();
-    const backupPath = await getBackupFilePath();
+    const settingsPath = getSettingsFilePath();
+    const backupPath = getBackupFilePath();
 
     await createBackupFile(settingsPath, backupPath);
     await saveFile(filePath, settingsPath);
@@ -134,5 +135,30 @@ const get = async () => {
     return readFile(settingsFilePath);
 };
 
-module.exports.setFromFilePath = setFromFilePath;
-module.exports.get = get;
+/**
+ * md5 hashes of default routes settings
+ */
+const defaultRoutesSettingHash = '3d180d52c663d173a6be791ef411ed01';
+
+const calculateHash = (data) => {
+    return crypto.createHash('md5')
+        .update(data, 'binary')
+        .digest('hex');
+};
+
+const getDefaultHash = () => {
+    return defaultRoutesSettingHash;
+};
+
+const getCurrentHash = async () => {
+    const data = await settingsLoader.loadSettings();
+
+    return calculateHash(JSON.stringify(data));
+};
+
+module.exports = {
+    getDefaultHash: getDefaultHash,
+    setFromFilePath: setFromFilePath,
+    get: get,
+    getCurrentHash: getCurrentHash
+};

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

@@ -0,0 +1,102 @@
+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 = {
+    settingsLoaderError: `Error trying to load YAML setting for {setting} from '{path}'.`
+};
+
+class SettingsLoader {
+    /**
+     * @param {Object} options
+     * @param {Function} options.parseYaml yaml parser
+     */
+    constructor({parseYaml}) {
+        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;
+    }
+
+    /**
+     * Functionally same as loadSettingsSync with exception of loading
+     * settings asynchronously. This method is used at new places to read settings
+     * to prevent blocking the eventloop
+     * @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 object = this.parseYaml(file);
+
+            debug('YAML settings file parsed:', filePath);
+
+            return validate(object);
+        } catch (err) {
+            if (errors.utils.isIgnitionError(err)) {
+                throw err;
+            }
+
+            throw new errors.GhostError({
+                message: tpl(messages.settingsLoaderError, {
+                    setting: setting,
+                    path: filePath
+                }),
+                err: err
+            });
+        }
+    }
+
+    /**
+     * Reads the routes.yaml settings file and passes the
+     * file to the YAML parser which then returns a JSON object.
+     *
+     * @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 object = this.parseYaml(file);
+            return validate(object);
+        } catch (err) {
+            if (errors.utils.isIgnitionError(err)) {
+                throw err;
+            }
+
+            throw new errors.GhostError({
+                message: tpl(messages.settingsLoaderError, {
+                    setting: setting,
+                    path: filePath
+                }),
+                err: err
+            });
+        }
+    }
+}
+
+module.exports = SettingsLoader;

package/core/{frontend/services/settings → server/services/route-settings}/validate.js

@@ -1,11 +1,20 @@
 const _ = require('lodash');
 const debug = require('@tryghost/debug')('frontend:services:settings:validate');
-const {i18n} = require('../proxy');
+const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
 const bridge = require('../../../bridge');
 const _private = {};
 let RESOURCE_CONFIG;
 
+const messages = {
+    validationError: 'The following definition "{at}" is invalid: {reason}',
+    invalidResourceError: 'Resource key not supported. {resourceKey}',
+    invalidResourceHelp: 'Please use: tag, user, post or page.',
+    badDatError: 'Please wrap the data definition into a custom name.',
+    badDataHelp: 'Example:\n data:\n  my-tag:\n    resource: tags\n    ...\n',
+    authorDeprecatedError: 'Please choose a different name. We recommend not using author.'
+};
+
 _private.validateTemplate = function validateTemplate(object) {
     // CASE: /about/: about
     if (typeof object === 'string') {
@@ -42,7 +51,7 @@ _private.validateData = function validateData(object) {
 
         if (!shortForm.match(/.*\..*/)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: shortForm,
                     reason: 'Incorrect Format. Please use e.g. tag.recipes'
                 })
@@ -54,8 +63,8 @@ _private.validateData = function validateData(object) {
         if (!RESOURCE_CONFIG.QUERY[resourceKey] ||
             (Object.prototype.hasOwnProperty.call(RESOURCE_CONFIG.QUERY[resourceKey], 'internal') && RESOURCE_CONFIG.QUERY[resourceKey].internal === true)) {
             throw new errors.ValidationError({
-                message: `Resource key not supported. ${resourceKey}`,
-                help: 'Please use: tag, user, post or page.'
+                message: tpl(messages.invalidResourceError, {resourceKey}),
+                help: tpl(messages.invalidResourceHelp)
             });
         }
 
@@ -98,15 +107,15 @@ _private.validateData = function validateData(object) {
             // CASE: a name is required to define the data longform
             if (['resource', 'type', 'limit', 'order', 'include', 'filter', 'status', 'visibility', 'slug', 'redirect'].indexOf(key) !== -1) {
                 throw new errors.ValidationError({
-                    message: 'Please wrap the data definition into a custom name.',
-                    help: 'Example:\n data:\n  my-tag:\n    resource: tags\n    ...\n'
+                    message: tpl(messages.badDataError),
+                    help: tpl(messages.badDataHelp)
                 });
             }
 
             // @NOTE: We disallow author, because {{author}} is deprecated.
             if (key === 'author') {
                 throw new errors.ValidationError({
-                    message: 'Please choose a different name. We recommend not using author.'
+                    message: tpl(messages.authorDeprecatedError)
                 });
             }
 
@@ -133,7 +142,7 @@ _private.validateData = function validateData(object) {
             _.each(requiredQueryFields, (option) => {
                 if (!Object.prototype.hasOwnProperty.call(object.data[key], option)) {
                     throw new errors.ValidationError({
-                        message: i18n.t('errors.services.settings.yaml.validate', {
+                        message: tpl(messages.validationError, {
                             at: JSON.stringify(object.data[key]),
                             reason: `${option} is required.`
                         })
@@ -142,7 +151,7 @@ _private.validateData = function validateData(object) {
 
                 if (allowedQueryValues[option] && allowedQueryValues[option].indexOf(object.data[key][option]) === -1) {
                     throw new errors.ValidationError({
-                        message: i18n.t('errors.services.settings.yaml.validate', {
+                        message: tpl(messages.validationError, {
                             at: JSON.stringify(object.data[key]),
                             reason: `${object.data[key][option]} not supported. Please use ${_.uniq(allowedQueryValues[option])}.`
                         })
@@ -186,7 +195,7 @@ _private.validateData = function validateData(object) {
 _private.validateRoutes = function validateRoutes(routes) {
     if (routes.constructor !== Object) {
         throw new errors.ValidationError({
-            message: i18n.t('errors.services.settings.yaml.validate', {
+            message: tpl(messages.validationError, {
                 at: routes,
                 reason: '`routes` must be a YAML map.'
             })
@@ -197,7 +206,7 @@ _private.validateRoutes = function validateRoutes(routes) {
         // CASE: we hard-require trailing slashes for the index route
         if (!routingTypeObjectKey.match(/\/$/)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObjectKey,
                     reason: 'A trailing slash is required.'
                 })
@@ -207,7 +216,7 @@ _private.validateRoutes = function validateRoutes(routes) {
         // CASE: we hard-require leading slashes for the index route
         if (!routingTypeObjectKey.match(/^\//)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObjectKey,
                     reason: 'A leading slash is required.'
                 })
@@ -217,7 +226,7 @@ _private.validateRoutes = function validateRoutes(routes) {
         // CASE: you define /about/:
         if (!routingTypeObject) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObjectKey,
                     reason: 'Please define a template.'
                 }),
@@ -235,7 +244,7 @@ _private.validateRoutes = function validateRoutes(routes) {
 _private.validateCollections = function validateCollections(collections) {
     if (collections.constructor !== Object) {
         throw new errors.ValidationError({
-            message: i18n.t('errors.services.settings.yaml.validate', {
+            message: tpl(messages.validationError, {
                 at: collections,
                 reason: '`collections` must be a YAML map.'
             })
@@ -246,7 +255,7 @@ _private.validateCollections = function validateCollections(collections) {
         // CASE: we hard-require trailing slashes for the collection index route
         if (!routingTypeObjectKey.match(/\/$/)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObjectKey,
                     reason: 'A trailing slash is required.'
                 })
@@ -256,7 +265,7 @@ _private.validateCollections = function validateCollections(collections) {
         // CASE: we hard-require leading slashes for the collection index route
         if (!routingTypeObjectKey.match(/^\//)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObjectKey,
                     reason: 'A leading slash is required.'
                 })
@@ -265,7 +274,7 @@ _private.validateCollections = function validateCollections(collections) {
 
         if (!Object.prototype.hasOwnProperty.call(routingTypeObject, 'permalink')) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObjectKey,
                     reason: 'Please define a permalink route.'
                 }),
@@ -277,7 +286,7 @@ _private.validateCollections = function validateCollections(collections) {
 
         if (!routingTypeObject.permalink) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObjectKey,
                     reason: 'Please define a permalink route.'
                 }),
@@ -288,7 +297,7 @@ _private.validateCollections = function validateCollections(collections) {
         // CASE: we hard-require trailing slashes for the value/permalink route
         if (!routingTypeObject.permalink.match(/\/$/)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObject.permalink,
                     reason: 'A trailing slash is required.'
                 })
@@ -298,7 +307,7 @@ _private.validateCollections = function validateCollections(collections) {
         // CASE: we hard-require leading slashes for the value/permalink route
         if (!routingTypeObject.permalink.match(/^\//)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObject.permalink,
                     reason: 'A leading slash is required.'
                 })
@@ -308,7 +317,7 @@ _private.validateCollections = function validateCollections(collections) {
         // CASE: notation /:slug/ or /:primary_author/ is not allowed. We only accept /{{...}}/.
         if (routingTypeObject.permalink && routingTypeObject.permalink.match(/\/:\w+/)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObject.permalink,
                     reason: 'Please use the following notation e.g. /{slug}/.'
                 })
@@ -331,7 +340,7 @@ _private.validateCollections = function validateCollections(collections) {
 _private.validateTaxonomies = function validateTaxonomies(taxonomies) {
     if (taxonomies.constructor !== Object) {
         throw new errors.ValidationError({
-            message: i18n.t('errors.services.settings.yaml.validate', {
+            message: tpl(messages.validationError, {
                 at: taxonomies,
                 reason: '`taxonomies` must be a YAML map.'
             })
@@ -342,7 +351,7 @@ _private.validateTaxonomies = function validateTaxonomies(taxonomies) {
     _.each(taxonomies, (routingTypeObject, routingTypeObjectKey) => {
         if (!routingTypeObject) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObjectKey,
                     reason: 'Please define a taxonomy permalink route.'
                 }),
@@ -352,7 +361,7 @@ _private.validateTaxonomies = function validateTaxonomies(taxonomies) {
 
         if (!validRoutingTypeObjectKeys.includes(routingTypeObjectKey)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObjectKey,
                     reason: 'Unknown taxonomy.'
                 })
@@ -362,7 +371,7 @@ _private.validateTaxonomies = function validateTaxonomies(taxonomies) {
         // CASE: we hard-require trailing slashes for the taxonomie permalink route
         if (!routingTypeObject.match(/\/$/)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObject,
                     reason: 'A trailing slash is required.'
                 })
@@ -372,7 +381,7 @@ _private.validateTaxonomies = function validateTaxonomies(taxonomies) {
         // CASE: we hard-require leading slashes for the value/permalink route
         if (!routingTypeObject.match(/^\//)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObject,
                     reason: 'A leading slash is required.'
                 })
@@ -382,7 +391,7 @@ _private.validateTaxonomies = function validateTaxonomies(taxonomies) {
         // CASE: notation /:slug/ or /:primary_author/ is not allowed. We only accept /{{...}}/.
         if (routingTypeObject && routingTypeObject.match(/\/:\w+/)) {
             throw new errors.ValidationError({
-                message: i18n.t('errors.services.settings.yaml.validate', {
+                message: tpl(messages.validationError, {
                     at: routingTypeObject,
                     reason: 'Please use the following notation e.g. /{slug}/.'
                 })
@@ -425,7 +434,8 @@ module.exports = function validate(object) {
 
     debug('api version', apiVersion);
 
-    RESOURCE_CONFIG = require(`../routing/config/${apiVersion}`);
+    // TODO: extract this config outta here! the config should be passed into this module
+    RESOURCE_CONFIG = require(`../../../frontend/services/routing/config/${apiVersion}`);
 
     object.routes = _private.validateRoutes(object.routes);
     object.collections = _private.validateCollections(object.collections);

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

@@ -0,0 +1,53 @@
+const yaml = require('js-yaml');
+const tpl = require('@tryghost/tpl');
+const errors = require('@tryghost/errors');
+
+const messages = {
+    parsingError: {
+        message: 'Could not parse provided YAML file: {context}.',
+        help: 'Check provided file for typos and fix the named issues.'
+    },
+    invalidYamlFormat: {
+        message: 'YAML input cannot be a plain string. Check the format of your YAML file.',
+        help: 'https://ghost.org/docs/themes/routing/'
+    }
+};
+
+/**
+ * Takes a YAML formatted string and parses it and returns a JSON Object
+ * @param {String} file the YAML file utf8 encoded
+ * @returns {Object} parsed
+ */
+module.exports = function parseYaml(file) {
+    try {
+        const parsed = yaml.load(file);
+
+        // yaml.load passes almost every yaml code.
+        // Because of that, it's hard to detect if there's an error in the file.
+        // But one of the obvious errors is the plain string output.
+        // Here we check if the user made this mistake.
+        if (typeof parsed === 'string') {
+            throw new errors.IncorrectUsageError({
+                message: messages.invalidYamlFormat.message,
+                help: messages.invalidYamlFormat.help
+            });
+        }
+
+        return parsed;
+    } catch (error) {
+        if (errors.utils.isIgnitionError(error)) {
+            throw error;
+        }
+
+        // CASE: parsing failed, `js-yaml` tells us exactly what and where in the
+        // `reason` property as well as in the message.
+        // As the file uploaded is invalid, the person uploading must fix this - it's a 4xx error
+        throw new errors.IncorrectUsageError({
+            message: tpl(messages.parsingError.message, {context: error.reason}),
+            code: 'YAML_PARSER_ERROR',
+            context: error.message,
+            err: error,
+            help: messages.parsingError.help
+        });
+    }
+};