Add support for nested paths to reorderResultsByKey

Author: jack-guy

API_DOCS.md

@@ -182,7 +182,7 @@ Describes the shape and behaviour of the resources object you will pass to `getL
 | `docsLink`               | The URL for the documentation of the resource. Useful for others to verify information is correct, and may be used in stack traces.                                                                                                                      |
 | `batchKey`               | The argument to the resource that represents the list of entities we want to fetch. (e.g. 'user_ids')                                                                                                                                                    |
 | `newKey`                 | The argument we'll replace the batchKey with - should be a singular version of the `batchKey` (e.g. 'user_id')                                                                                                                                           |
-| `reorderResultsByKey`    | (Optional) If the resource itself does not guarantee ordering, use this to specify which key in the response objects corresponds to an element in `batchKey`. Transforms and re-order the response to the same order as requested from the DataLoaders.  |
+| `reorderResultsByKey`    | (Optional) If the resource itself does not guarantee ordering, use this to specify which key in the response objects corresponds to an element in `batchKey`. Transforms and re-order the response to the same order as requested from the DataLoaders. Can be a dot separated nested path.  |
 | `nestedPath`             | (Optional) If the resource returns the list of results in a nested path (e.g. `{ results: [ 1, 2, 3 ] }`), this tells the DataLoader where in the response to find the results. (e.g. 'results').                                                        |
 | `commaSeparatedBatchKey` | (Optional) Set to true if the interface of the resource takes the batch key as a comma separated list (rather than an array of IDs, as is more common). Default: false                                                                                   |
 | `isResponseDictionary`   | (Optional) Set to true if the batch resource returns the results as a dictionary with key mapped to values (instead of a list of items). If this option is supplied `reorderResultsByKey` should not be. Default: false                                  |

__tests__/implementation.test.js

@@ -196,6 +196,43 @@ test('batch endpoint (with reorderResultsByKey)', async () => {
     });
 });
 
+
+test('batch endpoint (with nested reorderResultsByKey path)', async () => {
+    const config = {
+        resources: {
+            foo: {
+                isBatchResource: true,
+                docsLink: 'example.com/docs/bar',
+                batchKey: 'foo_ids',
+                newKey: 'foo_id',
+                reorderResultsByKey: 'nested.foo_id',
+            },
+        },
+    };
+
+    const resources = {
+        foo: ({ foo_ids }) => {
+            expect(foo_ids).toEqual([1, 2, 3]);
+            return Promise.resolve([
+                { nested: { foo_id: 2, foo_value: 'world' } },
+                { nested: { foo_id: 1, foo_value: 'hello' } },
+                { nested: { foo_id: 3, foo_value: '!' } },
+            ]);
+        },
+    };
+
+    await createDataLoaders(config, async (getLoaders) => {
+        const loaders = getLoaders(resources);
+
+        const results = await loaders.foo.loadMany([{ foo_id: 1 }, { foo_id: 2 }, { foo_id: 3 }]);
+        expect(results).toEqual([
+            { nested: { foo_id: 1, foo_value: 'hello' } },
+            { nested: { foo_id: 2, foo_value: 'world' } },
+            { nested: { foo_id: 3, foo_value: '!' } },
+        ]);
+    });
+});
+
 test('batch endpoint (with nestedPath)', async () => {
     const config = {
         resources: {

schema.json

@@ -80,7 +80,7 @@
                 },
                 "reorderResultsByKey": {
                     "type": "string",
-                    "description": "(Optional) If the resource itself does not guarantee ordering, this key specifies which key in the response objects corresponds to an element in `batchKey`. We use this to transfrom and re-order the response to the same order as in batchKey."
+                    "description": "(Optional) If the resource itself does not guarantee ordering, this key specifies which key in the response objects corresponds to an element in `batchKey`. We use this to transfrom and re-order the response to the same order as in batchKey. Can be a dot separated nested path."
                 },
                 "nestedPath": {
                     "type": "string",

src/runtimeHelpers.ts

@@ -169,7 +169,7 @@ export function sortByKeys<V>({
     items,
     /** The IDs we originally requested from the endpoint */
     keys,
-    /** The attribute of each element in `items` that maps it to an element in `keys`. */
+    /** The attribute of each element in `items` that maps it to an element in `keys`. Can be a dot-separated nested path. */
     prop,
     /** Some path that indicates what resource this is being used on. Used for stack traces. */
     resourcePath,
@@ -212,10 +212,9 @@ export function sortByKeys<V>({
 
             itemsMap.set(String(reorderResultsByValue), item);
         } else {
-            // @ts-ignore: TODO: Work how to tell typescript item[prop] exists
-            invariant(item[prop] != null, `${errorPrefix(resourcePath)} Could not find property "${prop}" in item`);
-            // @ts-ignore: TODO: Work how to tell typescript item[prop] exists
-            itemsMap.set(String(item[prop]), item);
+            const sortKey = _.get(item, prop);
+            invariant(sortKey != null, `${errorPrefix(resourcePath)} Could not find property "${prop}" in item`);
+            itemsMap.set(String(sortKey), item);
         }
     });