feat(Feature): load a feature's dependencies when it is loaded

Author: jedwards1211

README.md

@@ -88,7 +88,7 @@ initialization in the background.
 
 ### Feature API
 
-The following optionkal properties on features are handled by `redux-features`.  However, you may add any other
+The following optional properties on features are handled by `redux-features`.  However, you may add any other
 properties you want.
 * `reducer: (state, action) => state`: a reducer to apply to the top-level redux state for each action
 * `middleware: store => next => action => any`: middleware to apply for each action
@@ -97,6 +97,8 @@ properties you want.
   return a promise that will resolve to the full feature after loading.  The full feature **will replace
   the current feature in the redux state**, so initial properties of the feature will be blown away unless you merge
   them into the full feature yourself.
+* `dependencies: Array<string>`: an array of feature ids to load when this feature is loaded.  Circular feature
+  dependencies are not supported, and the behavior is undefined.
 
 ## Quick start
 

src/index.js.flow

@@ -42,6 +42,7 @@ export type FeatureStates = {[featureId: string]: FeatureState}
 export type Feature<S, A> = {
   init?: (store: MiddlewareAPI<S, A>) => any,
   load?: (store: MiddlewareAPI<S, A>) => Promise<Feature<S, A>>,
+  dependencies?: Array<string>,
   middleware?: Middleware<S, A>,
   reducer?: Reducer<S, A>,
 }

src/loadFeatureMiddleware.js

@@ -41,17 +41,20 @@ export default function loadFeatureMiddleware<S, A: {type: $Subtype<string>}>(
           return Promise.reject(error)
         }
 
-        return (
-          feature.load(store)
-            .catch((error: Error) => {
-              store.dispatch(setFeatureState(id, error)) // https://github.com/facebook/flow/issues/2993
-              throw error
-            })
-            .then((feature: Feature<S, A>): Feature<S, A> => {
-              store.dispatch(installFeature(id, feature)) // https://github.com/facebook/flow/issues/2993
-              return feature
-            })
-        )
+        const featurePromise = feature.load(store)
+        const {dependencies} = feature
+        const promises = Array.isArray(dependencies)
+          ? [...dependencies.map(id => store.dispatch(loadFeature(id))), featurePromise]
+          : [featurePromise]
+
+        return Promise.all(promises).then((features: Array<Feature<S, A>>): Feature<S, A> => {
+          const feature = features[features.length - 1]
+          store.dispatch(installFeature(id, feature))
+          return feature
+        }).catch((error: Error) => {
+          store.dispatch(setFeatureState(id, error))
+          throw error
+        })
       }
       return Promise.reject(new Error('missing feature for id: ', +id))
     },

test/loadFeatureMiddlewareTest.js

@@ -6,7 +6,7 @@ import featuresReducer from '../src/featuresReducer'
 import featureStatesReducer from '../src/featureStatesReducer'
 import loadFeatureMiddleware from '../src/loadFeatureMiddleware'
 import {addFeature, loadFeature, setFeatureState, installFeature, loadInitialFeatures} from '../src/actions'
-import {expect} from 'chai'
+import {expect, assert} from 'chai'
 import sinon from 'sinon'
 
 describe('loadFeatureMiddleware', () => {
@@ -16,6 +16,17 @@ describe('loadFeatureMiddleware', () => {
     return createStore(reducer, initialState, applyMiddleware(loadFeatureMiddleware(config)))
   }
 
+  function createFullStore(initialState, config) {
+    return createStore(
+      combineReducers({
+        featureStates: featureStatesReducer(config),
+        features: featuresReducer(config),
+      }),
+      initialState,
+      applyMiddleware(loadFeatureMiddleware(config))
+    )
+  }
+
   beforeEach(() => reducer.reset())
 
   function tests(createTestStore) {
@@ -264,8 +275,100 @@ describe('loadFeatureMiddleware', () => {
             })
           })
       })
-      it("returns a promise that rejects when any feature fails to load", () => {
-
+      it("returns a promise that rejects when any feature fails to load", async () => {
+        const error = new Error("test!")
+        const store = createStore(combineReducers({
+          featureStates: featureStatesReducer(),
+          features: featuresReducer(),
+        }), {
+          featureStates: {
+            f1: 'LOADED',
+            f2: 'LOADED',
+            f3: 'NOT_LOADED',
+          },
+          features: {
+            f1: {
+              load: () => Promise.reject(error)
+            },
+            f2: {
+              load: () => new Promise(resolve => setTimeout(() => resolve({b: 2}), 100))
+            },
+            f3: {},
+          }
+        }, applyMiddleware(loadFeatureMiddleware()))
+        try {
+          await store.dispatch(loadInitialFeatures())
+          assert.fail('loadInitialFeatures should have rejected')
+        } catch (e) {
+          expect(e).to.equal(error)
+        }
+        expect(store.getState().featureStates).to.deep.equal({
+          f1: error,
+          f2: 'LOADING',
+          f3: 'NOT_LOADED',
+        })
+      })
+    })
+    describe('on features with dependencies', () => {
+      it("loads dependencies", async() => {
+        const loadedDependency = {something: 'cool'}
+        const loadedFeature = {hello: 'world'}
+        const store = createFullStore({
+          featureStates: {
+            f1: 'NOT_LOADED',
+            f2: 'NOT_LOADED',
+          },
+          features: {
+            f1: {
+              load: (store) => Promise.resolve(loadedDependency)
+            },
+            f2: {
+              dependencies: ['f1'],
+              load: (store) => Promise.resolve(loadedFeature)
+            }
+          }
+        })
+        const result = await store.dispatch(loadFeature('f2'))
+        expect(result).to.equal(loadedFeature)
+        expect(store.getState()).to.deep.equal({
+          featureStates: {
+            f1: 'LOADED',
+            f2: 'LOADED',
+          },
+          features: {
+            f1: loadedDependency,
+            f2: loadedFeature,
+          }
+        })
+      })
+      it("rejects if any dependencies fail to load", async () => {
+        const loadedFeature = {hello: 'world'}
+        const error = new Error("test!")
+        const store = createFullStore({
+          featureStates: {
+            f1: 'NOT_LOADED',
+            f2: 'NOT_LOADED',
+          },
+          features: {
+            f1: {
+              load: (store) => Promise.reject(error)
+            },
+            f2: {
+              dependencies: ['f1'],
+              load: (store) => Promise.resolve(loadedFeature)
+            }
+          }
+        })
+        try {
+          await store.dispatch(loadFeature('f2'))
+          assert.fail('loadFeature should have rejected')
+        } catch (e) {
+          expect(e).to.equal(error)
+        }
+        expect(store.getState().featureStates).to.deep.equal({
+          f1: error,
+          f2: error,
+        })
       })
     })
   }