Switch default resolver to return promise and reject undefined keys with proper error messages

Author: StefanSlehta

src/default-resolver.js

@@ -1,9 +1,23 @@
+export const defaultErrors = [{message: 'an unknown error has occured'}];
+
 export default function defaultResolver(path) {
   const keys = path.split('.');
 
-  return function({model}) {
-    return keys.reduce((ref, key) => {
-      return ref[key];
-    }, model);
+  return function({model, errors}) {
+    return new Promise((resolve, reject) => {
+      try {
+        const result = keys.reduce((ref, key) => {
+          return ref[key];
+        }, model);
+
+        resolve(result);
+      } catch (_) {
+        if (errors) {
+          reject(errors);
+        } else {
+          reject(defaultErrors);
+        }
+      }
+    });
   };
 }

test/default-resolver-test.js

@@ -1,13 +1,15 @@
 import assert from 'assert';
-import defaultResolver from '../src/default-resolver';
+import defaultResolver, {defaultErrors} from '../src/default-resolver';
 
 suite('default-resolver-test', () => {
   test('it resolves a given key', () => {
     const value = 'a value';
     const object = {aKey: value};
     const resolve = defaultResolver('aKey');
 
-    assert.equal(resolve({model: object}), value);
+    return resolve({model: object}).then((resolvedValue) => {
+      assert.equal(resolvedValue, value);
+    });
   });
 
   test('it resolves a given path', () => {
@@ -23,6 +25,37 @@ suite('default-resolver-test', () => {
     };
     const resolve = defaultResolver('refOne.refTwo.refThree.refFour');
 
-    assert.equal(resolve({model: object}), value);
+    return resolve({model: object}).then((resolvedValue) => {
+      assert.equal(resolvedValue, value);
+    });
+  });
+
+  test('it rejects with top level errors hash if available', () => {
+    const errors = [
+      {
+        message: 'an error message'
+      }
+    ];
+    const resolve = defaultResolver('node');
+
+    return resolve({errors}).then(() => {
+      assert.ok(false, 'should not resolve');
+    }).catch((resolvedErrors) => {
+      assert.equal(resolvedErrors, errors);
+
+      return true;
+    });
+  });
+
+  test('it rejects with synthetic errors hash if no top level key available', () => {
+    const resolve = defaultResolver('node');
+
+    return resolve({}).then(() => {
+      assert.ok(false, 'should not resolve');
+    }).catch((resolvedErrors) => {
+      assert.equal(resolvedErrors, defaultErrors);
+
+      return true;
+    });
   });
 });