gatsby 2.10.3 → 2.11.1

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.11.1](https://github.com/gatsbyjs/gatsby/compare/gatsby@2.11.0...gatsby@2.11.1) (2019-06-28)
+
+### Features
+
+- **gatsby:** Rewrite resource loading - retry mechanism ([#14889](https://github.com/gatsbyjs/gatsby/issues/14889)) ([68e15e7](https://github.com/gatsbyjs/gatsby/commit/68e15e7))
+
+# [2.11.0](https://github.com/gatsbyjs/gatsby/compare/gatsby@2.10.5...gatsby@2.11.0) (2019-06-27)
+
+### Bug Fixes
+
+- **gatsby:** update tsc definition of cache in NodePluginArgs ([#14955](https://github.com/gatsbyjs/gatsby/issues/14955)) ([65b42e9](https://github.com/gatsbyjs/gatsby/commit/65b42e9))
+
+### Features
+
+- **gatsby:** enable babel-loader for all dependencies ([#14111](https://github.com/gatsbyjs/gatsby/issues/14111)) ([268ed27](https://github.com/gatsbyjs/gatsby/commit/268ed27))
+- **gatsby:** Support absolute certificate paths for developme… ([#14932](https://github.com/gatsbyjs/gatsby/issues/14932)) ([7694c0c](https://github.com/gatsbyjs/gatsby/commit/7694c0c))
+
+## [2.10.5](https://github.com/gatsbyjs/gatsby/compare/gatsby@2.10.4...gatsby@2.10.5) (2019-06-25)
+
+**Note:** Version bump only for package gatsby
+
+## [2.10.4](https://github.com/gatsbyjs/gatsby/compare/gatsby@2.10.3...gatsby@2.10.4) (2019-06-24)
+
+### Bug Fixes
+
+- **gatsby:** Fix client side routing match paths regression ([#15010](https://github.com/gatsbyjs/gatsby/issues/15010)) ([f52bbac](https://github.com/gatsbyjs/gatsby/commit/f52bbac))
+
 ## [2.10.3](https://github.com/gatsbyjs/gatsby/compare/gatsby@2.10.2...gatsby@2.10.3) (2019-06-24)
 
 **Note:** Version bump only for package gatsby

package/cache-dir/__tests__/__snapshots__/loader.js.snap

@@ -0,0 +1,15 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`BaseLoader loadPage should be successful when component can be loaded 1`] = `
+Object {
+  "component": "instance",
+  "json": Object {
+    "pageContext": "something something",
+  },
+  "page": Object {
+    "componentChunkName": "chunk",
+    "path": "/mypage/",
+    "webpackCompilationHash": "123",
+  },
+}
+`;

package/cache-dir/__tests__/loader.js

@@ -0,0 +1,428 @@
+// This is by no means a full test file for loader.js so feel free to add more tests.
+import mock from "xhr-mock"
+import { BaseLoader } from "../loader"
+import emitter from "../emitter"
+
+jest.mock(`../emitter`)
+
+describe(`BaseLoader`, () => {
+  describe(`loadPageDataJson`, () => {
+    let originalBasePath
+    let originalPathPrefix
+    let xhrCount
+
+    /**
+     * @param {string} path
+     * @param {number} status
+     * @param {boolean} json
+     */
+    const mockPageData = (path, status, json) => {
+      mock.get(`/page-data${path}/page-data.json`, (req, res) => {
+        xhrCount++
+        if (json) {
+          res.header(`content-type`, `application/json`)
+        }
+        return res.status(status).body(json ? `{ "path": "${path}/" }` : ``)
+      })
+    }
+
+    // replace the real XHR object with the mock XHR object before each test
+    beforeEach(() => {
+      originalBasePath = global.__BASE_PATH__
+      originalPathPrefix = global.__PATH_PREFIX__
+      global.__BASE_PATH__ = ``
+      global.__PATH_PREFIX__ = ``
+      xhrCount = 0
+      mock.setup()
+    })
+
+    // put the real XHR object back and clear the mocks after each test
+    afterEach(() => {
+      global.__BASE_PATH__ = originalBasePath
+      global.__PATH_PREFIX__ = originalPathPrefix
+      mock.teardown()
+    })
+
+    it(`should return a pageData json on success`, async () => {
+      const baseLoader = new BaseLoader(null, [])
+
+      mockPageData(`/mypage`, 200, true)
+
+      const expectation = {
+        status: `success`,
+        pagePath: `/mypage`,
+        payload: { path: `/mypage/` },
+      }
+      expect(await baseLoader.loadPageDataJson(`/mypage/`)).toEqual(expectation)
+      expect(baseLoader.pageDataDb.get(`/mypage`)).toEqual(expectation)
+      expect(xhrCount).toBe(1)
+    })
+
+    it(`should load a 404 page when page-path file is not a json`, async () => {
+      const baseLoader = new BaseLoader(null, [])
+
+      mockPageData(`/unknown-page`, 200, false)
+      mockPageData(`/404.html`, 200, true)
+
+      const expectation = {
+        status: `success`,
+        pagePath: `/404.html`,
+        notFound: true,
+        payload: {
+          path: `/404.html/`,
+        },
+      }
+      expect(await baseLoader.loadPageDataJson(`/unknown-page/`)).toEqual(
+        expectation
+      )
+      expect(baseLoader.pageDataDb.get(`/unknown-page`)).toEqual(expectation)
+      expect(xhrCount).toBe(2)
+    })
+
+    it(`should load a 404 page when path returns a 404`, async () => {
+      const baseLoader = new BaseLoader(null, [])
+
+      mockPageData(`/unknown-page`, 200, false)
+      mockPageData(`/404.html`, 200, true)
+
+      const expectation = {
+        status: `success`,
+        pagePath: `/404.html`,
+        notFound: true,
+        payload: {
+          path: `/404.html/`,
+        },
+      }
+      expect(await baseLoader.loadPageDataJson(`/unknown-page/`)).toEqual(
+        expectation
+      )
+      expect(baseLoader.pageDataDb.get(`/unknown-page`)).toEqual(expectation)
+      expect(xhrCount).toBe(2)
+    })
+
+    it(`should return a failure when status is 404 and 404 page is fetched`, async () => {
+      const baseLoader = new BaseLoader(null, [])
+
+      mockPageData(`/unknown-page`, 404, false)
+      mockPageData(`/404.html`, 404, false)
+
+      const expectation = {
+        status: `failure`,
+        pagePath: `/404.html`,
+        notFound: true,
+      }
+      expect(await baseLoader.loadPageDataJson(`/unknown-page/`)).toEqual(
+        expectation
+      )
+      expect(baseLoader.pageDataDb.get(`/unknown-page`)).toEqual(expectation)
+      expect(xhrCount).toBe(2)
+    })
+
+    it(`should return an error when status is 500`, async () => {
+      const baseLoader = new BaseLoader(null, [])
+
+      mockPageData(`/error-page`, 500, false)
+
+      const expectation = {
+        status: `error`,
+        pagePath: `/error-page`,
+      }
+      expect(await baseLoader.loadPageDataJson(`/error-page/`)).toEqual(
+        expectation
+      )
+      expect(baseLoader.pageDataDb.get(`/error-page`)).toEqual(expectation)
+      expect(xhrCount).toBe(1)
+    })
+
+    it(`should retry 3 times before returning an error`, async () => {
+      const baseLoader = new BaseLoader(null, [])
+
+      mockPageData(`/blocked-page`, 0, false)
+
+      const expectation = {
+        status: `error`,
+        retries: 3,
+        pagePath: `/blocked-page`,
+      }
+      expect(await baseLoader.loadPageDataJson(`/blocked-page/`)).toEqual(
+        expectation
+      )
+      expect(baseLoader.pageDataDb.get(`/blocked-page`)).toEqual(expectation)
+      expect(xhrCount).toBe(4)
+    })
+
+    it(`should recover if we get 1 failure`, async () => {
+      const baseLoader = new BaseLoader(null, [])
+
+      let xhrCount = 0
+      mock.get(`/page-data/blocked-page/page-data.json`, (req, res) => {
+        if (xhrCount++ === 0) {
+          return res.status(0).body(``)
+        } else {
+          res.header(`content-type`, `application/json`)
+          return res.status(200).body(`{ "path": "/blocked-page/" }`)
+        }
+      })
+
+      const expectation = {
+        status: `success`,
+        retries: 1,
+        pagePath: `/blocked-page`,
+        payload: {
+          path: `/blocked-page/`,
+        },
+      }
+      expect(await baseLoader.loadPageDataJson(`/blocked-page/`)).toEqual(
+        expectation
+      )
+      expect(baseLoader.pageDataDb.get(`/blocked-page`)).toEqual(expectation)
+      expect(xhrCount).toBe(2)
+    })
+
+    it(`shouldn't load pageData multiple times`, async () => {
+      const baseLoader = new BaseLoader(null, [])
+
+      mockPageData(`/mypage`, 200, true)
+
+      const expectation = await baseLoader.loadPageDataJson(`/mypage/`)
+      expect(await baseLoader.loadPageDataJson(`/mypage/`)).toBe(expectation)
+      expect(xhrCount).toBe(1)
+    })
+  })
+  describe(`loadPage`, () => {
+    beforeEach(() => emitter.emit.mockReset())
+
+    it(`should be successful when component can be loaded`, async () => {
+      const baseLoader = new BaseLoader(() => Promise.resolve(`instance`), [])
+      const pageData = {
+        path: `/mypage/`,
+        componentChunkName: `chunk`,
+        webpackCompilationHash: `123`,
+        result: {
+          pageContext: `something something`,
+        },
+      }
+      baseLoader.loadPageDataJson = jest.fn(() =>
+        Promise.resolve({
+          payload: pageData,
+          status: `success`,
+        })
+      )
+
+      const expectation = await baseLoader.loadPage(`/mypage/`)
+      expect(expectation).toMatchSnapshot()
+      expect(Object.keys(expectation)).toEqual([`component`, `json`, `page`])
+      expect(baseLoader.pageDb.get(`/mypage`)).toEqual(
+        expect.objectContaining({
+          payload: expectation,
+          status: `success`,
+        })
+      )
+      expect(emitter.emit).toHaveBeenCalledTimes(1)
+      expect(emitter.emit).toHaveBeenCalledWith(`onPostLoadPageResources`, {
+        page: expectation,
+        pageResources: expectation,
+      })
+    })
+
+    it(`should set not found on finalResult`, async () => {
+      const baseLoader = new BaseLoader(() => Promise.resolve(`instance`), [])
+      const pageData = {
+        path: `/mypage/`,
+        componentChunkName: `chunk`,
+        webpackCompilationHash: `123`,
+      }
+      baseLoader.loadPageDataJson = jest.fn(() =>
+        Promise.resolve({
+          payload: pageData,
+          status: `success`,
+          notFound: true,
+        })
+      )
+
+      await baseLoader.loadPage(`/mypage/`)
+      const expectation = baseLoader.pageDb.get(`/mypage`)
+      expect(expectation).toHaveProperty(`notFound`, true)
+      expect(emitter.emit).toHaveBeenCalledTimes(1)
+      expect(emitter.emit).toHaveBeenCalledWith(`onPostLoadPageResources`, {
+        page: expectation.payload,
+        pageResources: expectation.payload,
+      })
+    })
+
+    it(`should return an error when component cannot be loaded`, async () => {
+      const baseLoader = new BaseLoader(() => Promise.resolve(false), [])
+      const pageData = {
+        path: `/mypage/`,
+        componentChunkName: `chunk`,
+        webpackCompilationHash: `123`,
+      }
+      baseLoader.loadPageDataJson = jest.fn(() =>
+        Promise.resolve({
+          payload: pageData,
+          status: `success`,
+        })
+      )
+
+      await baseLoader.loadPage(`/mypage/`)
+      const expectation = baseLoader.pageDb.get(`/mypage`)
+      expect(expectation).toHaveProperty(`status`, `error`)
+      expect(emitter.emit).toHaveBeenCalledTimes(0)
+    })
+
+    it(`should return an error pageData contains an error`, async () => {
+      const baseLoader = new BaseLoader(() => Promise.resolve(`instance`), [])
+      const pageData = {
+        path: `/mypage/`,
+        componentChunkName: `chunk`,
+        webpackCompilationHash: `123`,
+      }
+      baseLoader.loadPageDataJson = jest.fn(() =>
+        Promise.resolve({
+          payload: pageData,
+          status: `error`,
+        })
+      )
+
+      expect(await baseLoader.loadPage(`/mypage/`)).toEqual({ status: `error` })
+      expect(baseLoader.pageDb.size).toBe(0)
+      expect(emitter.emit).toHaveBeenCalledTimes(0)
+    })
+
+    it(`should throw an error when 404 cannot be fetched`, async () => {
+      const baseLoader = new BaseLoader(() => Promise.resolve(`instance`), [])
+
+      baseLoader.loadPageDataJson = jest.fn(() =>
+        Promise.resolve({
+          status: `failure`,
+        })
+      )
+
+      try {
+        await baseLoader.loadPage(`/404.html/`)
+      } catch (err) {
+        expect(err.message).toEqual(
+          expect.stringContaining(`404 page could not be found`)
+        )
+      }
+      expect(baseLoader.pageDb.size).toBe(0)
+      expect(emitter.emit).toHaveBeenCalledTimes(0)
+    })
+
+    it(`should cache the result of loadPage`, async () => {
+      const baseLoader = new BaseLoader(() => Promise.resolve(`instance`), [])
+      baseLoader.loadPageDataJson = jest.fn(() =>
+        Promise.resolve({
+          payload: {},
+          status: `success`,
+        })
+      )
+
+      const expectation = await baseLoader.loadPage(`/mypage/`)
+      expect(await baseLoader.loadPage(`/mypage/`)).toBe(expectation)
+      expect(baseLoader.loadPageDataJson).toHaveBeenCalledTimes(1)
+    })
+
+    it(`should only run 1 network request even when called multiple times`, async () => {
+      const baseLoader = new BaseLoader(() => Promise.resolve(`instance`), [])
+      baseLoader.loadPageDataJson = jest.fn(() =>
+        Promise.resolve({
+          payload: {},
+          status: `success`,
+        })
+      )
+
+      const loadPagePromise = baseLoader.loadPage(`/test-page/`)
+      expect(baseLoader.inFlightDb.size).toBe(1)
+      expect(baseLoader.loadPage(`/test-page/`)).toBe(loadPagePromise)
+      expect(baseLoader.inFlightDb.size).toBe(1)
+
+      const expectation = await loadPagePromise
+
+      expect(baseLoader.inFlightDb.size).toBe(0)
+      expect(emitter.emit).toHaveBeenCalledTimes(1)
+      expect(emitter.emit).toHaveBeenCalledWith(`onPostLoadPageResources`, {
+        page: expectation,
+        pageResources: expectation,
+      })
+    })
+  })
+
+  describe(`loadPageSync`, () => {
+    it(`returns page resources when already fetched`, () => {
+      const baseLoader = new BaseLoader(null, [])
+
+      baseLoader.pageDb.set(`/mypage`, { payload: true })
+      expect(baseLoader.loadPageSync(`/mypage/`)).toBe(true)
+    })
+
+    it(`returns page resources when already fetched`, () => {
+      const baseLoader = new BaseLoader(null, [])
+
+      expect(baseLoader.loadPageSync(`/mypage/`)).toBeUndefined()
+    })
+  })
+
+  describe(`prefetch`, () => {
+    const flushPromises = () => new Promise(resolve => setImmediate(resolve))
+
+    it(`shouldn't prefetch when shouldPrefetch is false`, () => {
+      const baseLoader = new BaseLoader(null, [])
+      baseLoader.shouldPrefetch = jest.fn(() => false)
+      baseLoader.doPrefetch = jest.fn()
+
+      expect(baseLoader.prefetch(`/mypath/`)).toBe(false)
+      expect(baseLoader.shouldPrefetch).toHaveBeenCalledWith(`/mypath/`)
+      expect(baseLoader.doPrefetch).not.toHaveBeenCalled()
+    })
+
+    it(`should prefetch when not yet triggered`, async () => {
+      jest.useFakeTimers()
+      const baseLoader = new BaseLoader(null, [])
+      baseLoader.shouldPrefetch = jest.fn(() => true)
+      baseLoader.apiRunner = jest.fn()
+      baseLoader.doPrefetch = jest.fn(() => Promise.resolve({}))
+
+      expect(baseLoader.prefetch(`/mypath/`)).toBe(true)
+
+      // wait for doPrefetchPromise
+      await flushPromises()
+
+      expect(baseLoader.apiRunner).toHaveBeenCalledWith(`onPrefetchPathname`, {
+        pathname: `/mypath/`,
+      })
+      expect(baseLoader.apiRunner).toHaveBeenNthCalledWith(
+        2,
+        `onPostPrefetchPathname`,
+        {
+          pathname: `/mypath/`,
+        }
+      )
+    })
+
+    it(`should only run apis once`, async () => {
+      const baseLoader = new BaseLoader(null, [])
+      baseLoader.shouldPrefetch = jest.fn(() => true)
+      baseLoader.apiRunner = jest.fn()
+      baseLoader.doPrefetch = jest.fn(() => Promise.resolve({}))
+
+      expect(baseLoader.prefetch(`/mypath/`)).toBe(true)
+      expect(baseLoader.prefetch(`/mypath/`)).toBe(true)
+
+      // wait for doPrefetchPromise
+      await flushPromises()
+
+      expect(baseLoader.apiRunner).toHaveBeenCalledTimes(2)
+      expect(baseLoader.apiRunner).toHaveBeenNthCalledWith(
+        1,
+        `onPrefetchPathname`,
+        expect.anything()
+      )
+      expect(baseLoader.apiRunner).toHaveBeenNthCalledWith(
+        2,
+        `onPostPrefetchPathname`,
+        expect.anything()
+      )
+    })
+  })
+})

package/cache-dir/app.js

@@ -5,12 +5,17 @@ import domReady from "@mikaelkristiansson/domready"
 import socketIo from "./socketIo"
 import emitter from "./emitter"
 import { apiRunner, apiRunnerAsync } from "./api-runner-browser"
-import loader, { setApiRunnerForLoader } from "./loader"
+import { setLoader } from "./loader"
+import DevLoader from "./dev-loader"
 import syncRequires from "./sync-requires"
+// Generated during bootstrap
 import matchPaths from "./match-paths.json"
 
 window.___emitter = emitter
-setApiRunnerForLoader(apiRunner)
+
+const loader = new DevLoader(syncRequires, matchPaths)
+setLoader(loader)
+loader.setApiRunner(apiRunner)
 
 // Let the site/plugins run code very early.
 apiRunnerAsync(`onClientEntry`).then(() => {
@@ -49,8 +54,6 @@ apiRunnerAsync(`onClientEntry`).then(() => {
     ReactDOM.render
   )[0]
 
-  loader.addDevRequires(syncRequires)
-  loader.addMatchPaths(matchPaths)
   Promise.all([
     loader.loadPage(`/dev-404-page/`),
     loader.loadPage(`/404.html`),

package/cache-dir/commonjs/app.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
-
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
 var _react = _interopRequireDefault(require("react"));
@@ -16,14 +14,19 @@ var _emitter = _interopRequireDefault(require("./emitter"));
 
 var _apiRunnerBrowser = require("./api-runner-browser");
 
-var _loader = _interopRequireWildcard(require("./loader"));
+var _loader = require("./loader");
+
+var _devLoader = _interopRequireDefault(require("./dev-loader"));
 
 var _syncRequires = _interopRequireDefault(require("./sync-requires"));
 
 var _matchPaths = _interopRequireDefault(require("./match-paths.json"));
 
+// Generated during bootstrap
 window.___emitter = _emitter.default;
-(0, _loader.setApiRunnerForLoader)(_apiRunnerBrowser.apiRunner); // Let the site/plugins run code very early.
+const loader = new _devLoader.default(_syncRequires.default, _matchPaths.default);
+(0, _loader.setLoader)(loader);
+loader.setApiRunner(_apiRunnerBrowser.apiRunner); // Let the site/plugins run code very early.
 
 (0, _apiRunnerBrowser.apiRunnerAsync)(`onClientEntry`).then(() => {
   // Hook up the client to socket.io on server
@@ -52,12 +55,7 @@ window.___emitter = _emitter.default;
 
   const rootElement = document.getElementById(`___gatsby`);
   const renderer = (0, _apiRunnerBrowser.apiRunner)(`replaceHydrateFunction`, undefined, _reactDom.default.render)[0];
-
-  _loader.default.addDevRequires(_syncRequires.default);
-
-  _loader.default.addMatchPaths(_matchPaths.default);
-
-  Promise.all([_loader.default.loadPage(`/dev-404-page/`), _loader.default.loadPage(`/404.html`), _loader.default.loadPage(window.location.pathname)]).then(() => {
+  Promise.all([loader.loadPage(`/dev-404-page/`), loader.loadPage(`/404.html`), loader.loadPage(window.location.pathname)]).then(() => {
     const preferDefault = m => m && m.default || m;
 
     let Root = preferDefault(require(`./root`));

package/cache-dir/commonjs/dev-loader.js

@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _loader = require("./loader");
+
+class DevLoader extends _loader.BaseLoader {
+  constructor(syncRequires, matchPaths) {
+    const loadComponent = chunkName => Promise.resolve(syncRequires.components[chunkName]);
+
+    super(loadComponent, matchPaths);
+  }
+
+  loadPage(pagePath) {
+    const realPath = this.pathFinder.find(pagePath);
+    return super.loadPage(realPath).then(result => {
+      require(`./socketIo`).getPageData(realPath);
+
+      return result;
+    });
+  }
+
+  loadPageDataJson(rawPath) {
+    return super.loadPageDataJson(rawPath).then(data => {
+      // when we can't find a proper 404.html we fallback to dev-404-page
+      if (data.status === `failure`) {
+        return this.loadPageDataJson(`/dev-404-page/`);
+      }
+
+      return data;
+    });
+  }
+
+  doPrefetch(pagePath) {
+    return Promise.resolve(require(`./socketIo`).getPageData(pagePath));
+  }
+
+}
+
+var _default = DevLoader;
+exports.default = _default;