export separate functions instead of single function from lib/page-data

Author: sarahs

lib/page-data.js

@@ -6,44 +6,41 @@ const nonEnterpriseDefaultVersion = require('./non-enterprise-default-version')
 const englishPath = path.join(__dirname, '..', 'content')
 
 /**
- * This function creates three representions of pages we need for different purposes:
- *
- * 1. siteTree: A nested object with pages for every language and version, useful for nav because it
- * contains parent, child, and sibling relationships:
- * siteTree[languageCode][version].childPages[<array of pages>].childPages[<array of pages>] (etc...)
- *
- * 2. pageMap: A map of all pages with permalinks as keys for fast lookup.
- *
- * 3. pageList: A simple array of all page objects for fast iterating.
+ * We only need to initialize pages _once per language_ since pages don't change per version. So we do that
+ * first since it's the most expensive work. This gets us a nested object with pages attached that we can use
+ * as the basis for the siteTree after we do some versioning. We can also use it to derive the pageList.
 */
-module.exports = async function loadPageData () {
-  /**
-   * We only need to initialize pages _once per language_ since pages don't change per version. So we do that
-   * first since it's the most expensive work. This gets us a nested object with pages attached that we can use
-   * as the basis for the siteTree after we do some versioning.
-  */
-  const rawTree = {}
+async function loadUnversionedTree () {
+  const unversionedTree = {}
 
   await Promise.all(Object.values(languages)
     .map(async (langObj) => {
-      rawTree[langObj.code] = await createTree(englishPath, langObj)
+      unversionedTree[langObj.code] = await createTree(englishPath, langObj)
     }))
 
-  /**
-   * Now that we have the object of all pages per language, we can walk it for each version and do a couple operations:
-   * 1. Add a versioned href to every item, where the href is the relevant permalink for the current version.
-   *   A) Add an entry for the permalink in the pageMap.
-   * 2. Drop any child pages that are not available in the current version.
-   * Note that order of languages and versions doesn't matter, but order of child page arrays DOES matter (for navigation).
-  */
+  return unversionedTree
+}
+
+/**
+ * The siteTree is a nested object with pages for every language and version, useful for nav because it
+ * contains parent, child, and sibling relationships:
+ *
+ * siteTree[languageCode][version].childPages[<array of pages>].childPages[<array of pages>] (etc...)
+
+* Given an unversioned tree of all pages per language, we can walk it for each version and do a couple operations:
+ * 1. Add a versioned href to every item, where the href is the relevant permalink for the current version.
+ * 2. Drop any child pages that are not available in the current version.
+ *
+ * Order of languages and versions doesn't matter, but order of child page arrays DOES matter (for navigation).
+*/
+async function loadSiteTree (unversionedTree) {
+  const rawTree = Object.assign({}, (unversionedTree || await loadUnversionedTree()))
   const siteTree = {}
-  const pageMap = {}
 
   await Promise.all(Object.keys(languages).map(async (langCode) => {
     const treePerVersion = {}
 
     await Promise.all(versions.map(async (version) => {
-      // Yes, we are mutating the rawTree object here...
       versionPages(rawTree[langCode])
 
       // This step can't be asynchronous because the order of child pages matters.
@@ -53,9 +50,6 @@ module.exports = async function loadPageData () {
           .find(pl => pl.pageVersion === version || (pl.pageVersion === 'homepage' && version === nonEnterpriseDefaultVersion))
           .href
 
-        // Add permalinks to the pageMap.
-        pageMap[item.href] = item.page
-
         if (!item.childPages) return item
 
         // Drop child pages that do not apply to the current version.
@@ -71,8 +65,53 @@ module.exports = async function loadPageData () {
     siteTree[langCode] = treePerVersion
   }))
 
-  // Get a simple array of pages.
-  const pageList = [...new Set(Object.values(pageMap))]
+  return siteTree
+}
+
+// Derive a flat array of Page objects in all languages.
+async function loadPageList (unversionedTree) {
+  const rawTree = unversionedTree || await loadUnversionedTree()
+  const pageList = []
+
+  await Promise.all(Object.keys(languages).map(async (langCode) => {
+    await addToCollection(rawTree[langCode], pageList)
+  }))
+
+  async function addToCollection (item, collection) {
+    if (!item.page) return
+    collection.push(item.page)
+
+    if (!item.childPages) return
+    await Promise.all(item.childPages.map(async (childPage) => await addToCollection(childPage, collection)))
+  }
+
+  return pageList
+}
+
+// Create an object from the list of all pages with permalinks as keys for fast lookup.
+function createMapFromArray (pageList) {
+  const pageMap =
+    pageList.reduce(
+      (pageMap, page) => {
+        for (const permalink of page.permalinks) {
+          pageMap[permalink.href] = page
+        }
+        return pageMap
+      },
+      {}
+    )
+
+  return pageMap
+}
+
+async function loadPageMap (pageList) {
+  const pages = pageList || await loadPageList()
+  return createMapFromArray(pages)
+}
 
-  return { siteTree, pageList, pageMap }
+module.exports = {
+  loadUnversionedTree,
+  loadSiteTree,
+  loadPages: loadPageList,
+  loadPageMap
 }

lib/warm-server2.js

@@ -1,22 +1,25 @@
 const statsd = require('./statsd')
-const loadPageData = require('./page-data')
+const { loadUnversionedTree, loadSiteTree, loadPages, loadPageMap } = require('./page-data')
 const loadRedirects = require('./redirects/precompile')
 const loadSiteData = require('./site-data')
 
 // Instrument these functions so that
 // it's wrapped in a timer that reports to Datadog
 const dog = {
-  loadPageData: statsd.asyncTimer(loadPageData, 'load_page_data'),
+  loadUnversionedTree: statsd.asyncTimer(loadUnversionedTree, 'load_unversioned_tree'),
+  loadSiteTree: statsd.asyncTimer(loadSiteTree, 'load_site_tree'),
+  loadPages: statsd.asyncTimer(loadPages, 'load_pages'),
+  loadPageMap: statsd.asyncTimer(loadPageMap, 'load_page_map'),
   loadRedirects: statsd.asyncTimer(loadRedirects, 'load_redirects'),
   loadSiteData: statsd.timer(loadSiteData, 'load_site_data')
 }
 
 // For local caching
-let pageList, pageMap, site, redirects, siteTree
+let pageList, pageMap, site, redirects, unversionedTree, siteTree
 
 function isFullyWarmed () {
   // NOTE: Yes, `pageList` is specifically excluded here as it is transient data
-  const fullyWarmed = !!(pageMap && site && redirects && siteTree)
+  const fullyWarmed = !!(pageMap && site && redirects && unversionedTree && siteTree)
   return fullyWarmed
 }
 
@@ -25,6 +28,7 @@ function getWarmedCache () {
     pages: pageMap,
     site,
     redirects,
+    unversionedTree,
     siteTree
   }
 }
@@ -36,11 +40,20 @@ async function warmServer () {
     console.log('Priming context information...')
   }
 
+  if (!unversionedTree) {
+    unversionedTree = await dog.loadUnversionedTree()
+  }
+
   if (!siteTree) {
-    const pageData = await dog.loadPageData()
-    siteTree = pageData.siteTree
-    pageList = pageData.pageList
-    pageMap = pageData.pageMap
+    siteTree = await dog.loadSiteTree(unversionedTree)
+  }
+
+  if (!pageList) {
+    pageList = await dog.loadPages(unversionedTree)
+  }
+
+  if (!pageMap) {
+    pageMap = await dog.loadPageMap(pageList)
   }
 
   if (!site) {