ghost 4.48.0 → 5.0.0

package/core/server/services/members/middleware.js

@@ -2,14 +2,8 @@ const _ = require('lodash');
 const logging = require('@tryghost/logging');
 const membersService = require('./service');
 const models = require('../../models');
-const offersService = require('../offers/service');
 const urlUtils = require('../../../shared/url-utils');
-const ghostVersion = require('@tryghost/version');
-const settingsCache = require('../../../shared/settings-cache');
 const {formattedMemberResponse} = require('./utils');
-const labsService = require('../../../shared/labs');
-const config = require('../../../shared/config');
-const newslettersService = require('../newsletters');
 
 // @TODO: This piece of middleware actually belongs to the frontend, not to the member app
 // Need to figure a way to separate these things (e.g. frontend actually talks to members API)
@@ -61,14 +55,6 @@ const getMemberData = async function (req, res) {
     }
 };
 
-const getOfferData = async function (req, res) {
-    const offerId = req.params.id;
-    const offer = await offersService.api.getOffer({id: offerId});
-    return res.json({
-        offers: [offer]
-    });
-};
-
 const getMemberNewsletters = async function (req, res) {
     try {
         const memberUuid = req.query.uuid;
@@ -149,114 +135,6 @@ const updateMemberData = async function (req, res) {
     }
 };
 
-const getPortalProductPrices = async function () {
-    const page = await membersService.api.productRepository.list({
-        withRelated: ['monthlyPrice', 'yearlyPrice', 'benefits']
-    });
-
-    const products = page.data.map((productModel) => {
-        const product = productModel.toJSON();
-        const productPrices = [];
-        if (product.monthlyPrice) {
-            productPrices.push(product.monthlyPrice);
-        }
-        if (product.yearlyPrice) {
-            productPrices.push(product.yearlyPrice);
-        }
-        return {
-            id: product.id,
-            name: product.name,
-            description: product.description || '',
-            monthlyPrice: product.monthlyPrice,
-            yearlyPrice: product.yearlyPrice,
-            benefits: product.benefits,
-            active: product.active,
-            type: product.type,
-            visibility: product.visibility,
-            prices: productPrices
-        };
-    }).filter((product) => {
-        return !!product.active;
-    });
-    const defaultProduct = products.find((product) => {
-        return product.type === 'paid';
-    });
-    const defaultPrices = defaultProduct ? defaultProduct.prices : [];
-    let portalProducts = defaultProduct ? [defaultProduct] : [];
-    if (labsService.isSet('multipleProducts')) {
-        portalProducts = products;
-    }
-
-    return {
-        prices: defaultPrices,
-        products: portalProducts
-    };
-};
-
-const getSiteNewsletters = async function () {
-    try {
-        return await newslettersService.browse({filter: 'status:active', limit: 'all'});
-    } catch (err) {
-        logging.warn('Failed to fetch site newsletters');
-        logging.warn(err.message);
-        return [];
-    }
-};
-
-const getMemberSiteData = async function (req, res) {
-    const isStripeConfigured = membersService.config.isStripeConnected();
-    const domain = urlUtils.urlFor('home', true).match(new RegExp('^https?://([^/:?#]+)(?:[/:?#]|$)', 'i'));
-    const firstpromoterId = settingsCache.get('firstpromoter') ? settingsCache.get('firstpromoter_id') : '';
-    const blogDomain = domain && domain[1];
-    let supportAddress = settingsCache.get('members_support_address') || 'noreply';
-    if (!supportAddress.includes('@')) {
-        supportAddress = `${supportAddress}@${blogDomain}`;
-    }
-    const {products = [], prices = []} = await getPortalProductPrices() || {};
-    const portalVersion = config.get('portal:version');
-    const newsletters = await getSiteNewsletters();
-    const response = {
-        title: settingsCache.get('title'),
-        description: settingsCache.get('description'),
-        logo: settingsCache.get('logo'),
-        icon: settingsCache.get('icon'),
-        accent_color: settingsCache.get('accent_color'),
-        url: urlUtils.urlFor('home', true),
-        version: ghostVersion.safe,
-        portal_version: portalVersion,
-        free_price_name: settingsCache.get('members_free_price_name'),
-        free_price_description: settingsCache.get('members_free_price_description'),
-        allow_self_signup: membersService.config.getAllowSelfSignup(),
-        members_signup_access: settingsCache.get('members_signup_access'),
-        is_stripe_configured: isStripeConfigured,
-        portal_button: settingsCache.get('portal_button'),
-        portal_name: settingsCache.get('portal_name'),
-        portal_plans: settingsCache.get('portal_plans'),
-        portal_button_icon: settingsCache.get('portal_button_icon'),
-        portal_button_signup_text: settingsCache.get('portal_button_signup_text'),
-        portal_button_style: settingsCache.get('portal_button_style'),
-        firstpromoter_id: firstpromoterId,
-        members_support_address: supportAddress,
-        prices,
-        products
-    };
-
-    if (labsService.isSet('multipleNewsletters')) {
-        response.newsletters = newsletters;
-    }
-
-    if (labsService.isSet('multipleProducts')) {
-        response.portal_products = settingsCache.get('portal_products');
-    }
-    if (config.get('portal_sentry') && !config.get('portal_sentry').disabled) {
-        response.portal_sentry = {
-            dsn: config.get('portal_sentry').dsn,
-            env: config.get('env')
-        };
-    }
-    res.json({site: response});
-};
-
 const createSessionFromMagicLink = async function (req, res, next) {
     if (!req.url.includes('token=')) {
         return next();
@@ -287,18 +165,10 @@ const createSessionFromMagicLink = async function (req, res, next) {
                 })
                 .find(sub => ['active', 'trialing'].includes(sub.status));
             if (mostRecentActiveSubscription) {
-                if (labsService.isSet('tierWelcomePages')) {
-                    customRedirect = mostRecentActiveSubscription.tier.welcome_page_url;
-                } else {
-                    customRedirect = settingsCache.get('members_paid_signup_redirect') || '';
-                }
+                customRedirect = mostRecentActiveSubscription.tier.welcome_page_url;
             } else {
-                if (labsService.isSet('tierWelcomePages')) {
-                    const freeTier = await models.Product.findOne({type: 'free'});
-                    customRedirect = freeTier && freeTier.get('welcome_page_url') || '';
-                } else {
-                    customRedirect = settingsCache.get('members_free_signup_redirect') || '';
-                }
+                const freeTier = await models.Product.findOne({type: 'free'});
+                customRedirect = freeTier && freeTier.get('welcome_page_url') || '';
             }
 
             if (customRedirect && customRedirect !== '/') {
@@ -331,9 +201,7 @@ module.exports = {
     getIdentityToken,
     getMemberNewsletters,
     getMemberData,
-    getOfferData,
     updateMemberData,
     updateMemberNewsletters,
-    getMemberSiteData,
     deleteSession
 };

package/core/server/services/members/service.js

@@ -18,7 +18,6 @@ const jobsService = require('../jobs');
 const VerificationTrigger = require('@tryghost/verification-trigger');
 const DomainEvents = require('@tryghost/domain-events');
 const {LastSeenAtUpdater} = require('@tryghost/members-events-service');
-const events = require('../../lib/common/events');
 const DatabaseInfo = require('@tryghost/database-info');
 
 const messages = {
@@ -74,32 +73,6 @@ module.exports = {
         const createMembersApiInstance = require('./api');
         const env = config.get('env');
 
-        events.on('settings.edited', async function (settingModel) {
-            if (labsService.isSet('multipleProducts')) {
-                return;
-            }
-
-            const key = settingModel.get('key');
-            const value = settingModel.get('value');
-
-            if (key === 'members_free_signup_redirect') {
-                try {
-                    await models.Product.forge().query().update('welcome_page_url', value).where('type', 'free');
-                } catch (err) {
-                    logging.error(err);
-                }
-                return;
-            }
-            if (key === 'members_paid_signup_redirect') {
-                try {
-                    await models.Product.forge().query().update('welcome_page_url', value).where('type', 'paid');
-                } catch (err) {
-                    logging.error(err);
-                }
-                return;
-            }
-        });
-
         // @TODO Move to stripe service
         if (env !== 'production') {
             if (stripeService.api.configured && stripeService.api.mode === 'live') {

package/core/server/services/members/settings.js

@@ -52,7 +52,7 @@ function createSettingsInstance(config) {
             return updateEmailTemplate({url, email, siteTitle});
         },
         getSigninURL(token, type) {
-            const signinURL = new URL(getApiUrl({version: 'v4', type: 'admin'}));
+            const signinURL = new URL(urlUtils.urlFor('api', {type: 'admin'}, true));
             signinURL.pathname = path.join(signinURL.pathname, '/settings/members/email/');
             signinURL.searchParams.set('token', token);
             signinURL.searchParams.set('action', type);
@@ -60,10 +60,6 @@ function createSettingsInstance(config) {
         }
     };
 
-    const getApiUrl = ({version, type}) => {
-        return urlUtils.urlFor('api', {version: version, versionType: type}, true);
-    };
-
     const magicLinkService = new MagicLink({
         transporter,
         tokenProvider: new SingleUseTokenProvider(models.SingleUseToken, MAGIC_LINK_TOKEN_VALIDITY),
@@ -73,7 +69,7 @@ function createSettingsInstance(config) {
         getSubject
     });
 
-    const sendEmailAddressUpdateMagicLink = ({email, type = 'fromAddressUpdate'}) => {
+    const sendEmailAddressUpdateMagicLink = ({email, type = 'supportAddressUpdate'}) => {
         const [,toDomain] = email.split('@');
         let fromEmail = `noreply@${toDomain}`;
         if (fromEmail === email) {
@@ -103,9 +99,7 @@ function createSettingsInstance(config) {
 
     const getAdminRedirectLink = ({type}) => {
         const adminUrl = urlUtils.urlFor('admin', true);
-        if (type === 'fromAddressUpdate') {
-            return urlUtils.urlJoin(adminUrl, `#/settings/members-email/?${type}=success`);
-        } else if (type === 'supportAddressUpdate') {
+        if (type === 'supportAddressUpdate') {
             return urlUtils.urlJoin(adminUrl, `#/settings/members/?${type}=success`);
         } else {
             return urlUtils.urlJoin(adminUrl, `#/site/`);

package/core/server/services/newsletters/service.js

@@ -3,6 +3,13 @@ const MagicLink = require('@tryghost/magic-link');
 const logging = require('@tryghost/logging');
 const verifyEmailTemplate = require('./emails/verify-email');
 const debug = require('@tryghost/debug')('services:newsletters');
+const tpl = require('@tryghost/tpl');
+const errors = require('@tryghost/errors');
+
+const messages = {
+    nameAlreadyExists: 'A newsletter with the same name already exists',
+    newsletterNotFound: 'Newsletter not found.'
+};
 
 class NewslettersService {
     /**
@@ -73,6 +80,23 @@ class NewslettersService {
         });
     }
 
+    /**
+     * @public
+     * @param {Object} options data (id, uuid, slug...)
+     * @param {Object} [options] options
+     * @returns {Promise<object>} JSONified Newsletter models
+     */
+    async read(data, options = {}) {
+        const newsletter = await this.NewsletterModel.findOne(data, options);
+
+        if (!newsletter) {
+            throw new errors.NotFoundError({
+                message: tpl(messages.newsletterNotFound)
+            });
+        }
+        return newsletter;
+    }
+
     /**
      * @public
      * @param {Object} [options] options
@@ -83,11 +107,13 @@ class NewslettersService {
 
         return newsletters.toJSON();
     }
+
     /**
      * @public
      * @param {object} attrs model properties
      * @param {Object} [options] options
-     * @param {Object} [options] options.transacting
+     * @param {boolean} [options.opt_in_existing] Opt in existing members
+     * @param {Object} [options.transacting]
      * @returns {Promise<{object}>} Newsetter Model with verification metadata
      */
     async add(attrs, options = {}) {
@@ -99,7 +125,9 @@ class NewslettersService {
             });
         }
 
-        await this.limitService.errorIfWouldGoOverLimit('newsletters');
+        if (!attrs.status || attrs.status === 'active') {
+            await this.limitService.errorIfWouldGoOverLimit('newsletters', options.transacting ? {transacting: options.transacting} : {});
+        }
 
         // remove any email properties that are not allowed to be set without verification
         const {cleanedAttrs, emailsToVerify} = await this.prepAttrsForEmailVerification(attrs);
@@ -108,8 +136,23 @@ class NewslettersService {
         const sortOrder = await this.NewsletterModel.getNextAvailableSortOrder(options);
         cleanedAttrs.sort_order = sortOrder;
 
-        // add the model now because we need the ID for sending verification emails
-        const newsletter = await this.NewsletterModel.add(cleanedAttrs, options);
+        let newsletter;
+        try {
+            // add the model now because we need the ID for sending verification emails
+            newsletter = await this.NewsletterModel.add(cleanedAttrs, options);
+        } catch (error) {
+            if (error.code && error.message.toLowerCase().indexOf('unique') !== -1) {
+                throw new errors.ValidationError({
+                    message: tpl(messages.nameAlreadyExists),
+                    property: 'name'
+                });
+            }
+
+            throw error;
+        }
+
+        // Load relations correctly
+        newsletter = await this.NewsletterModel.findOne({id: newsletter.id}, {...options, require: true});
 
         // subscribe existing members if opt_in_existing=true
         if (options.opt_in_existing) {
@@ -135,18 +178,43 @@ class NewslettersService {
     /**
      * @public
      * @param {object} attrs model properties
-     * @param {Object} [options] options
+     * @param {Object} options options
+     * @param {string} options.id Newsletter id to edit
+     * @param {Object} [options.transacting]
      * @returns {Promise<{object}>} Newsetter Model with verification metadata
      */
-    async edit(attrs, options = {}) {
+    async edit(attrs, options) {
+        const sharedOptions = _.pick(options, 'transacting');
+
         // fetch newsletter first so we can compare changed emails
-        const originalNewsletter = await this.NewsletterModel.findOne(options, {require: true});
+        const originalNewsletter = await this.NewsletterModel.findOne({id: options.id}, {...sharedOptions, require: true});
 
         const {cleanedAttrs, emailsToVerify} = await this.prepAttrsForEmailVerification(attrs, originalNewsletter);
 
-        const updatedNewsletter = await this.NewsletterModel.edit(cleanedAttrs, options);
+        if (originalNewsletter.get('status') !== 'active' && cleanedAttrs.status === 'active') {
+            await this.limitService.errorIfWouldGoOverLimit('newsletters', sharedOptions);
+        }
+
+        let updatedNewsletter;
+        
+        try {
+            updatedNewsletter = await this.NewsletterModel.edit(cleanedAttrs, options);
+        } catch (error) {
+            if (error.code && error.message.toLowerCase().indexOf('unique') !== -1) {
+                throw new errors.ValidationError({
+                    message: tpl(messages.nameAlreadyExists),
+                    property: 'name'
+                });
+            }
+
+            throw error;
+        }
 
-        return this.respondWithEmailVerification(updatedNewsletter, emailsToVerify);
+        // Load relations correctly in the response
+        updatedNewsletter = await this.NewsletterModel.findOne({id: updatedNewsletter.id}, {...options, require: true});
+        
+        await this.respondWithEmailVerification(updatedNewsletter, emailsToVerify);
+        return updatedNewsletter;
     }
 
     /**
@@ -249,7 +317,7 @@ class NewslettersService {
 
 /**
  * @typedef {object} ILimitService
- * @prop {(name: string) => Promise<void>} errorIfWouldGoOverLimit
+ * @prop {(name: string, options?: {transacting?: Object}) => Promise<void>} errorIfWouldGoOverLimit
  **/
 
 module.exports = NewslettersService;

package/core/server/services/posts/post-scheduling-service.js

@@ -3,7 +3,7 @@ const errors = require('@tryghost/errors');
 const moment = require('moment');
 const config = require('../../../shared/config');
 const urlUtils = require('../../../shared/url-utils');
-const api = require('../../api');
+const api = require('../../api').endpoints;
 
 const messages = {
     jobNotFound: 'Job not found.',
@@ -11,15 +11,6 @@ const messages = {
 };
 
 class PostSchedulingService {
-    /**
-     *
-     * @param {Object} options
-     * @param {String} options.apiVersion - api version
-     */
-    constructor({apiVersion}) {
-        this.api = api[apiVersion];
-    }
-
     /**
      * Publishes scheduled resource (a post or a page at the moment of writing)
      *
@@ -32,7 +23,7 @@ class PostSchedulingService {
     async publish(resourceType, id, force, options) {
         const publishAPostBySchedulerToleranceInMinutes = config.get('times').publishAPostBySchedulerToleranceInMinutes;
 
-        const result = await this.api[resourceType].read({id}, options);
+        const result = await api[resourceType].read({id}, options);
         const preScheduledResource = result[resourceType][0];
 
         const publishedAtMoment = moment(preScheduledResource.published_at);
@@ -51,7 +42,7 @@ class PostSchedulingService {
             updated_at: moment(preScheduledResource.updated_at).toISOString(true)
         }];
 
-        const editResult = await this.api[resourceType].edit(
+        const editResult = await api[resourceType].edit(
             editedResource,
             _.pick(options, ['context', 'id', 'transacting', 'forUpdate'])
         );
@@ -88,13 +79,10 @@ class PostSchedulingService {
 }
 
 /**
- * @param {string} apiVersion - API version to use within the service
  * @returns {PostSchedulingService} instance of the PostsService
  */
-const getPostSchedulingServiceInstance = (apiVersion) => {
-    return new PostSchedulingService({
-        apiVersion: apiVersion
-    });
+const getPostSchedulingServiceInstance = () => {
+    return new PostSchedulingService();
 };
 
 module.exports = getPostSchedulingServiceInstance;

package/core/server/services/posts/posts-service.js

@@ -3,14 +3,12 @@ const {BadRequestError} = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
 
 const messages = {
-    invalidEmailRecipientFilter: 'Invalid filter in email_recipient_filter param.',
     invalidVisibilityFilter: 'Invalid visibility filter.',
-    invalidNewsletterId: 'The newsletter_id parameter doesn\'t match any active newsletter.'
+    invalidEmailSegment: 'The email segment parameter doesn\'t contain a valid filter'
 };
 
 class PostsService {
-    constructor({mega, apiVersion, urlUtils, models, isSet}) {
-        this.apiVersion = apiVersion;
+    constructor({mega, urlUtils, models, isSet}) {
         this.mega = mega;
         this.urlUtils = urlUtils;
         this.models = models;
@@ -18,76 +16,33 @@ class PostsService {
     }
 
     async editPost(frame) {
-        let model;
-
-        // Make sure the newsletter_id is matching an active newsletter
-        if (frame.options.newsletter_id) {
-            const newsletter = await this.models.Newsletter.findOne({id: frame.options.newsletter_id}, {transacting: frame.options.transacting});
-            if (!newsletter || newsletter.get('status') !== 'active') {
-                throw new BadRequestError({
-                    message: messages.invalidNewsletterId
-                });
-            }
-        } else {
-            // Set the newsletter_id if it isn't passed to the API
-            // NOTE: this option is ignored if the newsletter_id is already set on the post.
-            // Never use frame.options.newsletter_id to do actual logic. Use model.newsletter_id after the edit.
-            const newsletters = await this.models.Newsletter.findPage({filter: 'status:active', limit: 1, columns: ['id']}, {transacting: frame.options.transacting});
-            if (newsletters.data.length > 0) {
-                frame.options.newsletter_id = newsletters.data[0].id;
-            }
-        }
-
-        if (!frame.options.email_recipient_filter && frame.options.send_email_when_published) {
-            await this.models.Base.transaction(async (transacting) => {
-                const options = {
-                    ...frame.options,
-                    transacting
-                };
-
-                /**
-                 * 1. We need to edit the post first in order to know what the visibility is.
-                 * 2. We can only pass the email_recipient_filter when we change the status.
-                 *
-                 * So, we first edit the post as requested, with all information except the status,
-                 * from there we can determine what the email_recipient_filter should be and then finish
-                 * the edit, with the status and the email_recipient_filter option.
-                 */
-                const status = frame.data.posts[0].status;
-                delete frame.data.posts[0].status;
-                const interimModel = await this.models.Post.edit(frame.data.posts[0], options);
-                frame.data.posts[0].status = status;
-
-                options.email_recipient_filter = interimModel.get('visibility') === 'paid' ? 'paid' : 'all';
-
-                model = await this.models.Post.edit(frame.data.posts[0], options);
-            });
-        } else {
-            model = await this.models.Post.edit(frame.data.posts[0], frame.options);
-        }
-
-        /**Handle newsletter email */
-        const emailRecipientFilter = model.get('email_recipient_filter');
-        if (emailRecipientFilter !== 'none') {
-            if (emailRecipientFilter !== 'all') {
+        // Make sure the newsletter is matching an active newsletter
+        // Note that this option is simply ignored if the post isn't published or scheduled
+        if (frame.options.newsletter && frame.options.email_segment) {
+            if (frame.options.email_segment !== 'all') {
                 // check filter is valid
                 try {
-                    await this.models.Member.findPage({filter: `subscribed:true+${emailRecipientFilter}`, limit: 1});
+                    await this.models.Member.findPage({filter: frame.options.email_segment, limit: 1});
                 } catch (err) {
                     return Promise.reject(new BadRequestError({
-                        message: tpl(messages.invalidEmailRecipientFilter),
+                        message: tpl(messages.invalidEmailSegment),
                         context: err.message
                     }));
                 }
             }
+        }
+
+        const model = await this.models.Post.edit(frame.data.posts[0], frame.options);
 
+        /**Handle newsletter email */
+        if (model.get('newsletter_id')) {
             const sendEmail = model.wasChanged() && this.shouldSendEmail(model.get('status'), model.previous('status'));
 
             if (sendEmail) {
                 let postEmail = model.relations.email;
 
                 if (!postEmail) {
-                    const email = await this.mega.addEmail(model, {...frame.options, apiVersion: this.apiVersion});
+                    const email = await this.mega.addEmail(model, frame.options);
                     model.set('email', email);
                 } else if (postEmail && postEmail.get('status') === 'failed') {
                     const email = await this.mega.retryFailedEmail(postEmail);
@@ -159,17 +114,15 @@ class PostsService {
 }
 
 /**
- * @param {string} apiVersion - API version to use within the service
  * @returns {PostsService} instance of the PostsService
  */
-const getPostServiceInstance = (apiVersion) => {
+const getPostServiceInstance = () => {
     const urlUtils = require('../../../shared/url-utils');
     const {mega} = require('../mega');
     const labs = require('../../../shared/labs');
     const models = require('../../models');
 
     return new PostsService({
-        apiVersion: apiVersion,
         mega: mega,
         urlUtils: urlUtils,
         models: models,

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

@@ -2,7 +2,6 @@ const ghostVersion = require('@tryghost/version');
 const settingsCache = require('../../../shared/settings-cache');
 const config = require('../../../shared/config');
 const urlUtils = require('../../../shared/url-utils');
-const labs = require('../../../shared/labs');
 
 module.exports = function getSiteProperties() {
     const siteProperties = {
@@ -15,11 +14,6 @@ module.exports = function getSiteProperties() {
         version: ghostVersion.safe
     };
 
-    if (labs.isSet('oauthLogin') && settingsCache.get('oauth_client_id') && settingsCache.get('oauth_client_secret')) {
-        // Only set the oauth flag if oauth is enabled to avoid API changes
-        siteProperties.oauth = true;
-    }
-
     if (config.get('client_sentry') && !config.get('client_sentry').disabled) {
         siteProperties.sentry_dsn = config.get('client_sentry').dsn;
         siteProperties.sentry_env = config.get('env');

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

@@ -28,9 +28,6 @@ module.exports = {
         return await defaultSettingsManager.ensureSettingsFileExists();
     },
 
-    get loadRouteSettingsSync() {
-        return settingsLoader.loadSettingsSync.bind(settingsLoader);
-    },
     get loadRouteSettings() {
         return settingsLoader.loadSettings.bind(settingsLoader);
     },

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

@@ -21,10 +21,9 @@ class SettingsLoader {
     }
 
     /**
-     * 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
+     * Reads the routes.yaml settings file and passes the
+    * file to the YAML parser which then returns a JSON object.
+     * @returns {Promise<RouteSettings>} settingsFileContents
      */
     async loadSettings() {
         try {
@@ -49,36 +48,13 @@ class SettingsLoader {
             });
         }
     }
-
-    /**
-     * 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() {
-        try {
-            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.isGhostError(err)) {
-                throw err;
-            }
-
-            throw new errors.InternalServerError({
-                message: tpl(messages.settingsLoaderError, {
-                    setting: 'routes',
-                    path: this.settingFilePath
-                }),
-                err: err
-            });
-        }
-    }
 }
 
 module.exports = SettingsLoader;
+
+/**
+ * @typedef {Object} RouteSettings
+ * @property {Object} routes
+ * @property {Object} collections
+ * @property {Object} taxonomies
+ */