fix(doesQueryContain): support recursive types

fix #2

Author: jedwards1211

src/doesQueryContain.js

@@ -30,8 +30,7 @@ export default function doesQueryContain(
 
   function doesNodeContain(node: Node, data: any, type: Type): boolean {
     if (type === targetType) {
-      if (!ids) return true
-      return data && ids.has(data[idField])
+      if (!ids || (data && ids.has(data[idField]))) return true
     }
     if (!type.name) return false
     const ancestorEntry = potentialAncestors.get(type)

test/doesQueryContain.js

@@ -155,4 +155,154 @@ describe(`doesQueryContain`, function() {
     expect(doesQueryContain(document, types, 'Device', data, new Set([5]))).to
       .be.false
   })
+  it(`recursive type test`, function() {
+    const document = gql`
+      {
+        MetadataItem(tag: "foo/bar") {
+          tag
+          Parent {
+            tag
+            Parent {
+              tag
+            }
+          }
+        }
+      }
+    `
+    const data = {
+      MetadataItem: {
+        tag: 'foo/bar',
+        __typename: 'MetadataItem',
+        Parent: {
+          tag: 'foo',
+          __typename: 'MetadataItem',
+          Parent: null,
+        },
+      },
+    }
+    expect(doesQueryContain(document, types, 'MetadataItem')).to.be.true
+    expect(
+      doesQueryContain(
+        document,
+        types,
+        'MetadataItem',
+        data,
+        new Set(['foo']),
+        'tag'
+      )
+    ).to.be.true
+    expect(
+      doesQueryContain(
+        document,
+        types,
+        'MetadataItem',
+        data,
+        new Set(['foo', 'foo/bar']),
+        'tag'
+      )
+    ).to.be.true
+    expect(
+      doesQueryContain(
+        document,
+        types,
+        'MetadataItem',
+        data,
+        new Set(['foo/bar']),
+        'tag'
+      )
+    ).to.be.true
+    expect(
+      doesQueryContain(
+        document,
+        types,
+        'MetadataItem',
+        data,
+        new Set(['foo/bar/baz']),
+        'tag'
+      )
+    ).to.be.false
+  })
+  it(`multi-step recursive type test`, function() {
+    const document = gql`
+      {
+        Organization(id: 2) {
+          id
+          Users {
+            edges {
+              node {
+                id
+                Organizations {
+                  edges {
+                    node {
+                      id
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    `
+    const data = {
+      Organization: {
+        id: 2,
+        Users: {
+          edges: [
+            {
+              node: {
+                id: 3,
+                Organizations: {
+                  edges: [
+                    {
+                      node: {
+                        id: 5,
+                      },
+                    },
+                    {
+                      node: {
+                        id: 6,
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+            {
+              node: {
+                id: 4,
+                Organizations: {
+                  edges: [
+                    {
+                      node: {
+                        id: 7,
+                      },
+                    },
+                    {
+                      node: {
+                        id: 8,
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      },
+    }
+
+    expect(
+      doesQueryContain(document, types, 'Organization', data, new Set([7]))
+    ).to.be.true
+    expect(
+      doesQueryContain(document, types, 'Organization', data, new Set([5, 8]))
+    ).to.be.true
+    expect(
+      doesQueryContain(document, types, 'Organization', data, new Set([2]))
+    ).to.be.true
+    expect(
+      doesQueryContain(document, types, 'Organization', data, new Set([3]))
+    ).to.be.false
+  })
 })

test/getPotentialAncestors.js

@@ -27,5 +27,11 @@ describe(`getPotentialAncestors`, function() {
     expect(ancestors.get(types.Organization).fields.has('CustomDashboards')).to
       .be.false
     expect(ancestors.get(types.CustomDashboards)).not.to.exist
+    expect(ancestors.get(types.MetadataItem).fields.has('Parent')).to.be.true
+
+    expect(getPotentialAncestors(types.MetadataItem).has(types.MetadataItem))
+    expect(getPotentialAncestors(types.Organization).has(types.User))
+    expect(getPotentialAncestors(types.User).has(types.Organization))
+    expect(getPotentialAncestors(types.Organization).has(types.Organization))
   })
 })