Ghost/core/server/services/routing/helpers/fetch-data.js
Katharina Irrgang b392d1925a
Dynamic Routing Beta (#9596)
refs #9601

### Dynamic Routing

This is the beta version of dynamic routing. 

- we had a initial implementation of "channels" available in the codebase
- we have removed and moved this implementation 
- there is now a centralised place for dynamic routing - server/services/routing
- each routing component is represented by a router type e.g. collections, routes, static pages, taxonomies, rss, preview of posts
- keep as much as possible logic of routing helpers, middlewares and controllers
- ensure test coverage
- connect all the things together
  - yaml file + validation
  - routing + routers
  - url service
  - sitemaps
  - url access
- deeper implementation of yaml validations
  - e.g. hard require slashes
- ensure routing hierarchy/order
  - e.g. you enable the subscriber app
  - you have a custom static page, which lives under the same slug /subscribe
  - static pages are stronger than apps
  - e.g. the first collection owns the post it has filtered
  - a post cannot live in two collections
- ensure apps are still working and hook into the routers layer (or better said: and register in the routing service)
- put as much as possible comments to the code base for better understanding
- ensure a clean debug log
- ensure we can unmount routes
  - e.g. you have a collection permalink of /:slug/ represented by {globals.permalink}
  - and you change the permalink in the admin to dated permalink
  - the express route get's refreshed from /:slug/ to /:year/:month/:day/:slug/
  - unmount without server restart, yey
- ensure we are backwards compatible
  - e.g. render home.hbs for collection index if collection route is /
  - ensure you can access your configured permalink from the settings table with {globals.permalink}

### Render 503 if url service did not finish

- return 503 if the url service has not finished generating the resource urls

### Rewrite sitemaps

- we have rewritten the sitemaps "service", because the url generator does no longer happen on runtime
- we generate all urls on bootstrap
- the sitemaps service will consume created resource and router urls
- these urls will be shown on the xml pages
- we listen on url events
- we listen on router events
- we no longer have to fetch the resources, which is nice
  - the urlservice pre-fetches resources and emits their urls
- the urlservice is the only component who knows which urls are valid
- i made some ES6 adaptions
- we keep the caching logic -> only regenerate xml if there is a change
- updated tests
- checked test coverage (100%)

### Re-work usage of Url utility

- replace all usages of `urlService.utils.urlFor` by `urlService.getByResourceId`
  - only for resources e.g. post, author, tag
- this is important, because with dynamic routing we no longer create static urls based on the settings permalink on runtime
- adapt url utility
- adapt tests
2018-06-05 19:02:20 +02:00

121 lines
3.8 KiB
JavaScript

/**
* # Fetch Data
* Dynamically build and execute queries on the API
*/
const _ = require('lodash'),
Promise = require('bluebird'),
urlService = require('../../url'),
api = require('../../../api'),
defaultPostQuery = {};
// The default settings for a default post query
const queryDefaults = {
type: 'browse',
resource: 'posts',
options: {}
};
/**
* Default post query needs to always include author, authors & tags
*
* @deprecated: `author`, will be removed in Ghost 2.0
*/
_.extend(defaultPostQuery, queryDefaults, {
options: {
include: 'author,authors,tags'
}
});
/**
* ## Process Query
* Takes a 'query' object, ensures that type, resource and options are set
* Replaces occurrences of `%s` in options with slugParam
* Converts the query config to a promise for the result
*
* @param {{type: String, resource: String, options: Object}} query
* @param {String} slugParam
* @returns {Promise} promise for an API call
*/
function processQuery(query, slugParam) {
query = _.cloneDeep(query);
// Ensure that all the properties are filled out
_.defaultsDeep(query, queryDefaults);
// Replace any slugs, see TaxonomyRouter. We replace any '%s' by the slug
_.each(query.options, function (option, name) {
query.options[name] = _.isString(option) ? option.replace(/%s/g, slugParam) : option;
});
// Return a promise for the api query
return api[query.resource][query.type](query.options);
}
/**
* ## Fetch Data
* Calls out to get posts per page, builds the final posts query & builds any additional queries
* Wraps the queries using Promise.props to ensure it gets named responses
* Does a first round of formatting on the response, and returns
*/
function fetchData(pathOptions, routerOptions) {
pathOptions = pathOptions || {};
routerOptions = routerOptions || {};
let postQuery = _.cloneDeep(defaultPostQuery),
props = {};
if (routerOptions.filter) {
postQuery.options.filter = routerOptions.filter;
}
if (pathOptions.hasOwnProperty('page')) {
postQuery.options.page = pathOptions.page;
}
if (pathOptions.hasOwnProperty('limit')) {
postQuery.options.limit = pathOptions.limit;
}
// CASE: always fetch post collection
// The filter can in theory contain a "%s" e.g. filter="primary_tag:%s"
props.posts = processQuery(postQuery, pathOptions.slug);
// CASE: fetch more data defined by the router e.g. tags, authors - see TaxonomyRouter
_.each(routerOptions.data, function (query, name) {
props[name] = processQuery(query, pathOptions.slug);
});
return Promise.props(props)
.then(function formatResponse(results) {
const response = _.cloneDeep(results.posts);
delete results.posts;
// CASE: does this post belong to this collection?
// EXCEPTION: Taxonomies always list the posts which belong to a tag/author.
if (!routerOptions.data && routerOptions.identifier) {
response.posts = _.filter(response.posts, (post) => {
if (urlService.owns(routerOptions.identifier, post.url)) {
return post;
}
});
}
// process any remaining data
if (!_.isEmpty(results)) {
response.data = {};
_.each(results, function (result, name) {
if (routerOptions.data[name].type === 'browse') {
response.data[name] = result;
} else {
response.data[name] = result[routerOptions.data[name].resource];
}
});
}
return response;
});
}
module.exports = fetchData;