ghost 4.19.1 → 4.20.3

package/core/frontend/apps/amp/lib/router.js

@@ -6,7 +6,7 @@ const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
 
 // Dirty requires
-const urlService = require('../../../services/url');
+const urlService = require('../../../../server/services/url');
 const helpers = require('../../../services/routing/helpers');
 const templateName = 'amp';
 

package/core/frontend/meta/author-url.js

@@ -1,4 +1,4 @@
-const urlService = require('../services/url');
+const urlService = require('../../server/services/url');
 const getContextObject = require('./context-object.js');
 
 function getAuthorUrl(data, absolute) {

package/core/frontend/meta/url.js

@@ -1,6 +1,6 @@
 const schema = require('../../server/data/schema').checks;
 const urlUtils = require('../../shared/url-utils');
-const urlService = require('../services/url');
+const urlService = require('../../server/services/url');
 
 // This cleans the url from any `/amp` postfixes, so we'll never
 // output a url with `/amp` in the end, except for the needed `amphtml`

package/core/frontend/services/proxy.js

@@ -46,6 +46,6 @@ module.exports = {
     // Labs utils for enabling/disabling helpers
     labs: require('../../shared/labs'),
     // URGH... Yuk (unhelpful comment :D)
-    urlService: require('./url'),
+    urlService: require('../../server/services/url'),
     urlUtils: require('../../shared/url-utils')
 };

package/core/frontend/services/routing/CollectionRouter.js

@@ -6,16 +6,13 @@ const controllers = require('./controllers');
 const middlewares = require('./middlewares');
 const RSSRouter = require('./RSSRouter');
 
-// This emits its own routing events AND listens to settings.timezone.edited :(
-const events = require('../../../server/lib/common/events');
-
 /**
  * @description Collection Router for post resource.
  *
  * Fundamental router to define where resources live and how their url structure is.
  */
 class CollectionRouter extends ParentRouter {
-    constructor(mainRoute, object, RESOURCE_CONFIG) {
+    constructor(mainRoute, object, RESOURCE_CONFIG, routerCreated) {
         super('CollectionRouter');
 
         this.RESOURCE_CONFIG = RESOURCE_CONFIG.QUERY.post;
@@ -55,11 +52,11 @@ class CollectionRouter extends ParentRouter {
         };
 
         this.context = [this.routerName];
+        this.routerCreated = routerCreated;
 
         debug(this.name, this.route, this.permalinks);
 
         this._registerRoutes();
-        this._listeners();
     }
 
     /**
@@ -92,7 +89,7 @@ class CollectionRouter extends ParentRouter {
         // REGISTER: permalinks e.g. /:slug/, /podcast/:slug
         this.mountRoute(this.permalinks.getValue({withUrlOptions: true}), controllers.entry);
 
-        events.emit('router.created', this);
+        this.routerCreated(this);
     }
 
     /**
@@ -127,43 +124,6 @@ class CollectionRouter extends ParentRouter {
         next();
     }
 
-    /**
-     * @description This router has listeners to react on changes which happen in Ghost.
-     * @private
-     */
-    _listeners() {
-        /**
-         * CASE: timezone changes
-         *
-         * If your permalink contains a date reference, we have to regenerate the urls.
-         *
-         * e.g. /:year/:month/:day/:slug/ or /:day/:slug/
-         */
-        this._onTimezoneEditedListener = this._onTimezoneEdited.bind(this);
-        events.on('settings.timezone.edited', this._onTimezoneEditedListener);
-    }
-
-    /**
-     * @description Helper function to handle a timezone change.
-     * @param settingModel
-     * @private
-     */
-    _onTimezoneEdited(settingModel) {
-        const newTimezone = settingModel.attributes.value;
-        const previousTimezone = settingModel._previousAttributes.value;
-
-        if (newTimezone === previousTimezone) {
-            return;
-        }
-
-        if (this.getPermalinks().getValue().match(/:year|:month|:day/)) {
-            debug('_onTimezoneEdited: trigger regeneration');
-
-            // @NOTE: The connected url generator will listen on this event and regenerate urls.
-            this.emit('updated');
-        }
-    }
-
     /**
      * @description Get resource type of this router (always "posts")
      * @returns {string}
@@ -196,12 +156,6 @@ class CollectionRouter extends ParentRouter {
 
         return urlUtils.createUrl(urlUtils.urlJoin(this.route.value, this.rssRouter.route.value), options.absolute, options.secure);
     }
-
-    reset() {
-        if (this._onTimezoneEditedListener) {
-            events.removeListener('settings.timezone.edited', this._onTimezoneEditedListener);
-        }
-    }
 }
 
 module.exports = CollectionRouter;

package/core/frontend/services/routing/ParentRouter.js

@@ -9,7 +9,6 @@
 
 const debug = require('@tryghost/debug')('routing:parent-router');
 
-const EventEmitter = require('events').EventEmitter;
 const express = require('../../../shared/express');
 const _ = require('lodash');
 const url = require('url');
@@ -46,10 +45,8 @@ function GhostRouter(options) {
     return innerRouter;
 }
 
-class ParentRouter extends EventEmitter {
+class ParentRouter {
     constructor(name) {
-        super();
-
         this.identifier = security.identifier.uid(10);
 
         this.name = name;

package/core/frontend/services/routing/StaticPagesRouter.js

@@ -3,17 +3,15 @@ const urlUtils = require('../../../shared/url-utils');
 const ParentRouter = require('./ParentRouter');
 const controllers = require('./controllers');
 
-// This emits its own routing events
-const events = require('../../../server/lib/common/events');
-
 /**
  * @description Resource: pages
  */
 class StaticPagesRouter extends ParentRouter {
-    constructor(RESOURCE_CONFIG) {
+    constructor(RESOURCE_CONFIG, routerCreated) {
         super('StaticPagesRouter');
 
         this.RESOURCE_CONFIG = RESOURCE_CONFIG.QUERY.page;
+        this.routerCreated = routerCreated;
 
         // @NOTE: Permalink is always /:slug, not configure able
         this.permalinks = {
@@ -50,7 +48,7 @@ class StaticPagesRouter extends ParentRouter {
         // REGISTER: permalink for static pages
         this.mountRoute(this.permalinks.getValue({withUrlOptions: true}), controllers.entry);
 
-        events.emit('router.created', this);
+        this.routerCreated(this);
     }
 
     /**

package/core/frontend/services/routing/StaticRoutesRouter.js

@@ -6,20 +6,18 @@ const controllers = require('./controllers');
 const middlewares = require('./middlewares');
 const ParentRouter = require('./ParentRouter');
 
-// This emits its own routing events
-const events = require('../../../server/lib/common/events');
-
 /**
  * @description Template routes allow you to map individual URLs to specific template files within a Ghost theme
  */
 class StaticRoutesRouter extends ParentRouter {
-    constructor(mainRoute, object) {
+    constructor(mainRoute, object, routerCreated) {
         super('StaticRoutesRouter');
 
         this.route = {value: mainRoute};
         this.templates = object.templates || [];
         this.data = object.data || {query: {}, router: {}};
         this.routerName = mainRoute === '/' ? 'index' : mainRoute.replace(/\//g, '');
+        this.routerCreated = routerCreated;
 
         debug(this.route.value, this.templates);
 
@@ -64,7 +62,7 @@ class StaticRoutesRouter extends ParentRouter {
         this.router().param('page', middlewares.pageParam);
         this.mountRoute(urlUtils.urlJoin(this.route.value, 'page', ':page(\\d+)'), controllers[this.controller]);
 
-        events.emit('router.created', this);
+        this.routerCreated(this);
     }
 
     /**
@@ -100,7 +98,7 @@ class StaticRoutesRouter extends ParentRouter {
         // REGISTER: static route
         this.mountRoute(this.route.value, controllers.static);
 
-        events.emit('router.created', this);
+        this.routerCreated(this);
     }
 
     /**

package/core/frontend/services/routing/TaxonomyRouter.js

@@ -6,15 +6,12 @@ const urlUtils = require('../../../shared/url-utils');
 const controllers = require('./controllers');
 const middlewares = require('./middlewares');
 
-// This emits its own routing events
-const events = require('../../../server/lib/common/events');
-
 /**
  * @description Taxonomies are groupings of posts based on a common relation.
  * Taxonomies do not change the url of a resource.
  */
 class TaxonomyRouter extends ParentRouter {
-    constructor(key, permalinks, RESOURCE_CONFIG) {
+    constructor(key, permalinks, RESOURCE_CONFIG, routerCreated) {
         super('Taxonomy');
 
         this.taxonomyKey = key;
@@ -28,6 +25,8 @@ class TaxonomyRouter extends ParentRouter {
             return this.permalinks.value;
         };
 
+        this.routerCreated = routerCreated;
+
         debug(this.permalinks);
 
         this._registerRoutes();
@@ -60,7 +59,7 @@ class TaxonomyRouter extends ParentRouter {
             this.mountRoute(urlUtils.urlJoin(this.permalinks.value, 'edit'), this._redirectEditOption.bind(this));
         }
 
-        events.emit('router.created', this);
+        this.routerCreated(this);
     }
 
     /**

package/core/frontend/services/routing/controllers/collection.js

@@ -3,7 +3,7 @@ const debug = require('@tryghost/debug')('services:routing:controllers:collectio
 const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
 const security = require('@tryghost/security');
-const bootstrap = require('../bootstrap');
+const {routerManager} = require('../');
 const themeEngine = require('../../theme-engine');
 const helpers = require('../helpers');
 
@@ -72,7 +72,7 @@ module.exports = function collectionController(req, res, next) {
              * People should always invert their filters to ensure that the database query loads unique posts per collection.
              */
             result.posts = _.filter(result.posts, (post) => {
-                if (bootstrap.internal.owns(res.routerOptions.identifier, post.id)) {
+                if (routerManager.owns(res.routerOptions.identifier, post.id)) {
                     return post;
                 }
 

package/core/frontend/services/routing/controllers/email-post.js

@@ -1,6 +1,6 @@
 const debug = require('@tryghost/debug')('services:routing:controllers:emailpost');
 const config = require('../../../../shared/config');
-const bootstrap = require('../bootstrap');
+const {routerManager} = require('../');
 const urlUtils = require('../../../../shared/url-utils');
 const helpers = require('../helpers');
 
@@ -48,7 +48,7 @@ module.exports = function emailPostController(req, res, next) {
             }
 
             if (post.status === 'published') {
-                return urlUtils.redirect301(res, bootstrap.internal.getUrlByResourceId(post.id, {withSubdirectory: true}));
+                return urlUtils.redirect301(res, routerManager.getUrlByResourceId(post.id, {withSubdirectory: true}));
             }
 
             if (res.locals.apiVersion !== 'v0.1' && res.locals.apiVersion !== 'v2') {

package/core/frontend/services/routing/controllers/entry.js

@@ -1,7 +1,7 @@
 const debug = require('@tryghost/debug')('services:routing:controllers:entry');
 const url = require('url');
 const config = require('../../../../shared/config');
-const bootstrap = require('../bootstrap');
+const {routerManager} = require('../');
 const urlUtils = require('../../../../shared/url-utils');
 const helpers = require('../helpers');
 
@@ -60,7 +60,7 @@ module.exports = function entryController(req, res, next) {
              *
              * That's why we have to check against the router type.
              */
-            if (bootstrap.internal.getResourceById(entry.id).config.type !== res.routerOptions.resourceType) {
+            if (routerManager.getResourceById(entry.id).config.type !== res.routerOptions.resourceType) {
                 debug('not my resource type');
                 return next();
             }

package/core/frontend/services/routing/controllers/preview.js

@@ -1,6 +1,6 @@
 const debug = require('@tryghost/debug')('services:routing:controllers:preview');
 const config = require('../../../../shared/config');
-const bootstrap = require('../bootstrap');
+const {routerManager} = require('../');
 const urlUtils = require('../../../../shared/url-utils');
 const helpers = require('../helpers');
 
@@ -50,7 +50,7 @@ module.exports = function previewController(req, res, next) {
             }
 
             if (post.status === 'published') {
-                return urlUtils.redirect301(res, bootstrap.internal.getUrlByResourceId(post.id, {withSubdirectory: true}));
+                return urlUtils.redirect301(res, routerManager.getUrlByResourceId(post.id, {withSubdirectory: true}));
             }
 
             if (res.locals.apiVersion !== 'v0.1' && res.locals.apiVersion !== 'v2') {

package/core/frontend/services/routing/index.js

@@ -1,21 +1,15 @@
+const registry = require('./registry');
+const RouterManager = require('./router-manager');
+const routerManager = new RouterManager({registry});
+
 module.exports = {
-    get bootstrap() {
-        return require('./bootstrap');
-    },
+    routerManager: routerManager,
 
     get registry() {
-        return require('./registry');
+        return registry;
     },
 
     get helpers() {
         return require('./helpers');
-    },
-
-    get CollectionRouter() {
-        return require('./CollectionRouter');
-    },
-
-    get TaxonomyRouter() {
-        return require('./TaxonomyRouter');
     }
 };

package/core/frontend/services/routing/registry.js

@@ -41,6 +41,19 @@ module.exports = {
         return routers[name];
     },
 
+    /**
+     * Gets a router by it's internal router name
+     * @param {String} name internal router name
+     * @returns {Express-Router}
+     */
+    getRouterByName(name) {
+        for (let routerKey in routers) {
+            if (routers[routerKey].name === name) {
+                return routers[routerKey];
+            }
+        }
+    },
+
     /**
      *
      *

package/core/frontend/services/routing/router-manager.js

@@ -0,0 +1,185 @@
+const debug = require('@tryghost/debug')('routing');
+const _ = require('lodash');
+const StaticRoutesRouter = require('./StaticRoutesRouter');
+const StaticPagesRouter = require('./StaticPagesRouter');
+const CollectionRouter = require('./CollectionRouter');
+const TaxonomyRouter = require('./TaxonomyRouter');
+const PreviewRouter = require('./PreviewRouter');
+const ParentRouter = require('./ParentRouter');
+const EmailRouter = require('./EmailRouter');
+const UnsubscribeRouter = require('./UnsubscribeRouter');
+
+// This emits its own routing events
+const events = require('../../../server/lib/common/events');
+
+class RouterManager {
+    constructor({registry, defaultApiVersion = 'v4'}) {
+        this.registry = registry;
+        this.defaultApiVersion = defaultApiVersion;
+        this.siteRouter = null;
+        this.urlService = null;
+    }
+
+    owns(routerId, id) {
+        return this.urlService.owns(routerId, id);
+    }
+
+    getUrlByResourceId(id, options) {
+        return this.urlService.getUrlByResourceId(id, options);
+    }
+
+    getResourceById(resourceId) {
+        return this.urlService.getResourceById(resourceId);
+    }
+
+    routerCreated(router) {
+        // NOTE: this event should be become an "internal frontend even"
+        //       and should not be consumed by the modules outside the frontend
+        events.emit('router.created', this);
+
+        // CASE: there are router types which do not generate resource urls
+        //       e.g. static route router, in this case we don't want ot notify the URL service
+        if (!router || !router.getPermalinks()) {
+            return;
+        }
+
+        this.urlService.onRouterAddedType(router);
+    }
+
+    /**
+     * @description The `init` function will return the wrapped parent express router and will start creating all
+     *              routers if you pass the option "start: true".
+     *
+     * CASES:
+     *   - if Ghost starts, it will first init the site app with the wrapper router and then call `start`
+     *     separately, because it could be that your blog goes into maintenance mode
+     *   - if you change your route settings, we will re-initialize routing
+     *
+     * @param {Object} options
+     * @param {Boolean} [options.start] - flag controlling if the frontend Routes should be reinitialized
+     * @param {String} options.apiVersion - API version frontend Routes should communicate through
+     * @param {Object} options.routerSettings - JSON configuration to build frontend Routes
+     * @param {Object} options.urlService - service providing resource URL utility functions such as owns, getUrlByResourceId, and getResourceById
+     * @returns {ExpressRouter}
+     */
+    init({start = false, routerSettings, apiVersion, urlService}) {
+        this.urlService = urlService;
+        debug('routing init', start, apiVersion, routerSettings);
+
+        this.registry.resetAllRouters();
+        this.registry.resetAllRoutes();
+
+        // NOTE: this event could become an "internal frontend" in the future, it's used has been kept to prevent
+        //       from tying up this module with sitemaps
+        events.emit('routers.reset');
+
+        this.siteRouter = new ParentRouter('SiteRouter');
+        this.registry.setRouter('siteRouter', this.siteRouter);
+
+        if (start) {
+            apiVersion = apiVersion || this.defaultApiVersion;
+            this.start(apiVersion, routerSettings);
+        }
+
+        return this.siteRouter.router();
+    }
+
+    /**
+     * @description This function will create the routers based on the route settings
+     *
+     * The routers are created in a specific order. This order defines who can get a resource first or
+     * who can dominant other routers.
+     *
+     * 1. Preview + Unsubscribe Routers: Strongest inbuilt features, which you can never override.
+     * 2. Static Routes: Very strong, because you can override any urls and redirect to a static route.
+     * 3. Taxonomies: Stronger than collections, because it's an inbuilt feature.
+     * 4. Collections
+     * 5. Static Pages: Weaker than collections, because we first try to find a post slug and fallback to lookup a static page.
+     * 6. Internal Apps: Weakest
+     *
+     * @param {string} apiVersion
+     * @param {object} routerSettings
+     */
+    start(apiVersion, routerSettings) {
+        debug('routing start', apiVersion, routerSettings);
+        const RESOURCE_CONFIG = require(`./config/${apiVersion}`);
+
+        const unsubscribeRouter = new UnsubscribeRouter();
+        this.siteRouter.mountRouter(unsubscribeRouter.router());
+        this.registry.setRouter('unsubscribeRouter', unsubscribeRouter);
+
+        const emailRouter = new EmailRouter(RESOURCE_CONFIG);
+        this.siteRouter.mountRouter(emailRouter.router());
+        this.registry.setRouter('emailRouter', emailRouter);
+
+        const previewRouter = new PreviewRouter(RESOURCE_CONFIG);
+        this.siteRouter.mountRouter(previewRouter.router());
+        this.registry.setRouter('previewRouter', previewRouter);
+
+        _.each(routerSettings.routes, (value, key) => {
+            const staticRoutesRouter = new StaticRoutesRouter(key, value, this.routerCreated.bind(this));
+            this.siteRouter.mountRouter(staticRoutesRouter.router());
+
+            this.registry.setRouter(staticRoutesRouter.identifier, staticRoutesRouter);
+        });
+
+        _.each(routerSettings.collections, (value, key) => {
+            const collectionRouter = new CollectionRouter(key, value, RESOURCE_CONFIG, this.routerCreated.bind(this));
+            this.siteRouter.mountRouter(collectionRouter.router());
+            this.registry.setRouter(collectionRouter.identifier, collectionRouter);
+        });
+
+        const staticPagesRouter = new StaticPagesRouter(RESOURCE_CONFIG, this.routerCreated.bind(this));
+        this.siteRouter.mountRouter(staticPagesRouter.router());
+
+        this.registry.setRouter('staticPagesRouter', staticPagesRouter);
+
+        _.each(routerSettings.taxonomies, (value, key) => {
+            const taxonomyRouter = new TaxonomyRouter(key, value, RESOURCE_CONFIG, this.routerCreated.bind(this));
+            this.siteRouter.mountRouter(taxonomyRouter.router());
+
+            this.registry.setRouter(taxonomyRouter.identifier, taxonomyRouter);
+        });
+
+        const appRouter = new ParentRouter('AppsRouter');
+        this.siteRouter.mountRouter(appRouter.router());
+
+        this.registry.setRouter('appRouter', appRouter);
+
+        debug('Routes:', this.registry.getAllRoutes());
+    }
+
+    /**
+     * This is a glue code to keep the implementation of routers away from
+     * this sort of logic. Ideally this method should not be ever called
+     * and handled completely on the URL Service layer without touching the frontend
+     * @param {Object} settingModel instance of the settings model
+     * @returns {void}
+     */
+    handleTimezoneEdit(settingModel) {
+        const newTimezone = settingModel.attributes.value;
+        const previousTimezone = settingModel._previousAttributes.value;
+
+        if (newTimezone === previousTimezone) {
+            return;
+        }
+
+        /**
+         * CASE: timezone changes
+         *
+         * If your permalink contains a date reference, we have to regenerate the urls.
+         *
+         * e.g. /:year/:month/:day/:slug/ or /:day/:slug/
+         */
+
+        // NOTE: timezone change only affects the collection router with dated permalinks
+        const collectionRouter = this.registry.getRouterByName('CollectionRouter');
+        if (collectionRouter.getPermalinks().getValue().match(/:year|:month|:day/)) {
+            debug('handleTimezoneEdit: trigger regeneration');
+
+            this.urlService.onRouterUpdated(collectionRouter);
+        }
+    }
+}
+
+module.exports = RouterManager;

package/core/frontend/services/rss/generate-feed.js

@@ -3,7 +3,7 @@ const Promise = require('bluebird');
 const cheerio = require('cheerio');
 const RSS = require('rss');
 const urlUtils = require('../../../shared/url-utils');
-const bootstrap = require('../routing/bootstrap');
+const {routerManager} = require('../routing');
 
 const generateTags = function generateTags(data) {
     if (data.tags) {
@@ -19,7 +19,7 @@ const generateTags = function generateTags(data) {
 };
 
 const generateItem = function generateItem(post, secure) {
-    const itemUrl = bootstrap.internal.getUrlByResourceId(post.id, {secure, absolute: true});
+    const itemUrl = routerManager.getUrlByResourceId(post.id, {secure, absolute: true});
     const htmlContent = cheerio.load(post.html || '');
     const item = {
         title: post.title,