Exposing getField and getModel utility functions. Fixes #424

Author: davidkpiano

src/index.js

@@ -19,7 +19,8 @@ import combineForms from './reducers/forms-reducer';
 import modelReducer from './reducers/model-reducer';
 
 import track from './utils/track';
-import getField from './utils/get-field';
+import getFieldFromState from './utils/get-field-from-state';
+import get from './utils/get';
 
 import form from './form';
 
@@ -53,6 +54,7 @@ export {
   form,
 
   // Utilities
-  getField,
+  getFieldFromState as getField,
+  get as getModel,
   track,
 };

src/utils/get-field-from-state.js

@@ -4,7 +4,9 @@ import getForm from './get-form';
 import isPlainObject from 'lodash/isPlainObject';
 
 export default function getFieldFromState(state, modelString) {
-  const form = getForm(state, modelString);
+  const form = (state && '$form' in state)
+    ? state
+    : getForm(state, modelString);
 
   if (!form) return null;
 

test/form-reducer-spec.js

@@ -1,5 +1,8 @@
 import { assert } from 'chai';
-import { actions, formReducer, initialFieldState, getField } from '../src';
+import {
+  actions,
+  formReducer,
+} from '../src';
 import isValid from '../src/form/is-valid';
 
 describe('formReducer()', () => {
@@ -15,38 +18,6 @@ describe('formReducer()', () => {
     assert.doesNotThrow(() => reducer(undefined, { type: 'ANY' }));
   });
 
-  describe('getField() function', () => {
-    it('should return an initialFieldState given an uninitialized model', () => {
-      const reducer = formReducer('test');
-
-      const actual = reducer(undefined, { type: 'ANY' });
-
-      assert.isFunction(getField);
-
-      assert.deepEqual(getField(actual, 'any'), initialFieldState);
-
-      assert.isObject(getField(actual, 'foo').errors);
-    });
-
-    it('should maintain the full fieldState of an updated model', () => {
-      const reducer = formReducer('test');
-
-      const actual = reducer(undefined, actions.focus('test.foo'));
-
-      assert.containSubset(getField(actual, 'foo'), {
-        focus: true,
-      });
-
-      assert.isObject(getField(actual, 'foo').errors);
-    });
-
-    it('should throw an error when given an invalid argument for form state', () => {
-      assert.throws(() => getField(true, 'foo'));
-      assert.throws(() => getField(undefined, 'foo'));
-      assert.throws(() => getField(null, 'foo'));
-    });
-  });
-
   describe('deep paths', () => {
     it('should be able to handle model at deep state path', () => {
       const reducer = formReducer('forms.test');

test/utils-spec.js

@@ -1,15 +1,21 @@
 import invertValidators from '../src/utils/invert-validators';
 import getValidity from '../src/utils/get-validity';
 import isValidityInvalid from '../src/utils/is-validity-invalid';
-import { getFormStateKey } from '../src/utils/get-form';
+import getForm, { getFormStateKey } from '../src/utils/get-form';
 import getFieldFromState from '../src/utils/get-field-from-state';
 import { createStore, applyMiddleware, combineReducers } from 'redux';
 import thunk from 'redux-thunk';
 import mapValues from 'lodash/mapValues';
 import _get from 'lodash/get';
 import { assert } from 'chai';
 
-import { actions, formReducer } from '../src';
+import {
+  actions,
+  formReducer,
+  getField,
+  getModel,
+  combineForms,
+} from '../src';
 
 describe('utils', () => {
   describe('invertValidators()', () => {
@@ -160,4 +166,118 @@ describe('utils', () => {
         'deep.deeper.thirdForm');
     });
   });
+
+  describe('getField()', () => {
+    beforeEach(() => getForm.clearCache());
+
+    it('should exist', () => {
+      assert.isFunction(getField);
+    });
+
+    const store = createStore(combineForms({
+      test: {
+        foo: 'foo',
+        deep: {
+          bar: 'bar',
+        },
+      },
+    }));
+
+    it('should find a field from a store', () => {
+      assert.containSubset(getField(store.getState(), 'test.foo'), {
+        model: 'test.foo',
+      });
+    });
+
+    it('should find a deep field from a store', () => {
+      assert.containSubset(getField(store.getState(), 'test.deep.bar'), {
+        model: 'test.deep.bar',
+      });
+    });
+
+    it('should find a nested form from a store', () => {
+      assert.containSubset(getField(store.getState(), 'test.deep'), {
+        model: 'test.deep',
+      });
+    });
+  });
+
+  describe('getModel', () => {
+    it('should exist', () => {
+      assert.isFunction(getModel);
+    });
+
+    const store = createStore(combineForms({
+      test: {
+        foo: 'foo',
+        deep: {
+          bar: 'bar',
+        },
+      },
+    }));
+
+    it('should find a model from a store', () => {
+      assert.equal(
+        getModel(store.getState(), 'test.foo'),
+        'foo');
+    });
+
+    it('should find a deep model from a store', () => {
+      assert.equal(
+        getModel(store.getState(), 'test.deep.bar'),
+        'bar');
+    });
+
+    it('should work with bracket notation', () => {
+      assert.equal(
+        getModel(store.getState(), 'test.deep["bar"]'),
+        'bar');
+
+      assert.equal(
+        getModel(store.getState(), 'test["deep"].bar'),
+        'bar');
+
+      assert.equal(
+        getModel(store.getState(), 'test["deep"]["bar"]'),
+        'bar');
+    });
+
+    it('should find a complex model from a store', () => {
+      assert.deepEqual(
+        getModel(store.getState(), 'test.deep'),
+        { bar: 'bar' });
+    });
+
+    it('should ignore stray periods', () => {
+      assert.equal(
+        getModel(store.getState(), 'test.foo.'),
+        'foo');
+    });
+
+    it('should ignore ending empty brackets', () => {
+      assert.equal(
+        getModel(store.getState(), 'test.foo[]'),
+        'foo');
+    });
+
+    it('should work when given a number index as path', () => {
+      const arrayStore = createStore(combineForms([
+        { foo: 'foo' },
+      ]));
+
+      assert.deepEqual(
+        getModel(arrayStore.getState(), 0),
+        { foo: 'foo' });
+    });
+
+    it('should work with an array path', () => {
+      assert.equal(
+        getModel(store.getState(), ['test', 'foo']),
+        'foo');
+
+      assert.equal(
+        getModel(store.getState(), ['test', 'deep', 'bar']),
+        'bar');
+    });
+  });
 });