Fix for issue #446 (#469)

* Fixes #446

Removes decideRelationTypeDirection as a result of refactoring the decision it was making when filtering the incoming direction of a relationship type. It had an undefined input argument for such cases, so a comparison was failing to ever result in swapping the variables for .from / .to nodes and reversing the relationship direction. This is done due to the use of a more static template once these variables get used to produce Cypher.

Also removes a few unused function arguments

* Adds test for #446 fix

Issue #446 occured when filtering incoming relationships through a relationship type. This case was not tested in the TCK. Only outgoing cases were tested when querying from Person to Company, filtering over the `Person.employmentHistory` field.

So a new test has been added that covers the reverse, querying from Company to Person, filtering over the `Company.employeeHistory` field.

Author: michaeldgraham

src/translate.js

@@ -333,9 +333,7 @@ export const relationTypeFieldOnNodeType = ({
   cypherParams
 }) => {
   if (innerSchemaTypeRelation.from === innerSchemaTypeRelation.to) {
-    tailParams.initial = `${initial}${fieldName}: {${
-      subSelection[0]
-    }}${skipLimit} ${commaIfTail}`;
+    tailParams.initial = `${initial}${fieldName}: {${subSelection[0]}}${skipLimit} ${commaIfTail}`;
     return [tailParams, subSelection];
   }
   const relationshipVariableName = `${nestedVariable}_relation`;
@@ -586,9 +584,7 @@ const directedNodeTypeFieldOnRelationType = ({
       }}]${!isArrayType(fieldType) ? ')' : ''}${skipLimit} ${commaIfTail}`;
       return [tailParams, subSelection];
     } else {
-      tailParams.initial = `${initial}${fieldName}: ${variableName} {${
-        subSelection[0]
-      }}${skipLimit} ${commaIfTail}`;
+      tailParams.initial = `${initial}${fieldName}: ${variableName} {${subSelection[0]}}${skipLimit} ${commaIfTail}`;
       // Case of a renamed directed field
       // e.g., 'from: Movie' -> 'Movie: Movie'
       return [tailParams, subSelection];
@@ -743,9 +739,7 @@ export const neo4jType = ({
   return {
     initial: `${initial}${fieldName}: ${
       fieldIsArray
-        ? `reduce(a = [], INSTANCE IN ${variableName}.${fieldName} | a + {${
-            subSelection[0]
-          }})${commaIfTail}`
+        ? `reduce(a = [], INSTANCE IN ${variableName}.${fieldName} | a + {${subSelection[0]}})${commaIfTail}`
         : temporalOrderingFieldExists(parentSchemaType, parentFilterParams)
         ? `${safeVariableName}.${fieldName}${commaIfTail}`
         : `{${subSelection[0]}}${commaIfTail}`
@@ -2147,9 +2141,6 @@ const processFilterArgument = ({
       schema
     });
     translations = translateFilterArguments({
-      fieldArgs,
-      params,
-      filterParamKey,
       filterFieldMap,
       filterCypherParam,
       rootIsRelationType,
@@ -2440,9 +2431,6 @@ const deserializeFilterFieldName = name => {
 };
 
 const translateFilterArguments = ({
-  fieldArgs,
-  params,
-  filterParamKey,
   filterFieldMap,
   filterCypherParam,
   variableName,
@@ -2460,9 +2448,6 @@ const translateFilterArguments = ({
         filterValue: value,
         rootIsRelationType,
         variableName,
-        fieldArgs,
-        params,
-        filterParamKey,
         schemaType,
         schema
       });
@@ -2483,9 +2468,6 @@ const translateFilterArgument = ({
   fieldName,
   rootIsRelationType,
   variableName,
-  fieldArgs,
-  params,
-  filterParamKey,
   filterParam,
   parentSchemaType,
   schemaType,
@@ -2544,9 +2526,6 @@ const translateFilterArgument = ({
       filterValue,
       variableName,
       fieldName,
-      fieldArgs,
-      params,
-      filterParamKey,
       filterParam,
       schema,
       parentSchemaType,
@@ -2744,9 +2723,6 @@ const translateInputFilter = ({
   filterValue,
   variableName,
   fieldName,
-  fieldArgs,
-  params,
-  filterParamKey,
   filterParam,
   schema,
   parentSchemaType,
@@ -2788,7 +2764,6 @@ const translateInputFilter = ({
         isReflexiveTypeDirectedField
       ] = decideRelationFilterMetadata({
         fieldName,
-        parentSchemaType,
         schemaType,
         variableName,
         innerSchemaType,
@@ -2995,7 +2970,6 @@ const translateRelationFilter = ({
 
 const decideRelationFilterMetadata = ({
   fieldName,
-  parentSchemaType,
   schemaType,
   variableName,
   innerSchemaType,
@@ -3028,28 +3002,39 @@ const decideRelationFilterMetadata = ({
     relatedType = typeVariables.typeName;
   } else if (innerRelationTypeDirective) {
     isRelationType = true;
-    [thisType, relatedType, relDirection] = decideRelationTypeDirection(
-      schemaType,
-      innerRelationTypeDirective
-    );
+    thisType = innerRelationTypeDirective.from;
+    relatedType = innerRelationTypeDirective.to;
+    relLabel = innerRelationTypeDirective.name;
+    relDirection = 'OUT';
     if (thisType === relatedType) {
       isReflexiveRelationType = true;
       if (fieldName === 'from') {
         isReflexiveTypeDirectedField = true;
         relDirection = 'IN';
       } else if (fieldName === 'to') {
         isReflexiveTypeDirectedField = true;
-        relDirection = 'OUT';
       }
     }
-    relLabel = innerRelationTypeDirective.name;
   } else if (relationTypeDirective) {
     isRelationTypeNode = true;
-    [thisType, relatedType, relDirection] = decideRelationTypeDirection(
-      parentSchemaType,
-      relationTypeDirective
-    );
+    thisType = relationTypeDirective.from;
+    relatedType = relationTypeDirective.to;
     relLabel = variableName;
+    relDirection = 'OUT';
+    // if not a reflexive relationship type
+    if (thisType !== relatedType) {
+      const filteredType =
+        innerSchemaType && innerSchemaType.name ? innerSchemaType.name : '';
+      // then the connecting node type field on a relationship type filter
+      // may be incoming or outgoing; thisType could be .from or .to
+      if (filteredType === thisType) {
+        // then a filter argument for the incoming direction is being used
+        // when querying the node type it goes out from
+        thisType = relatedType;
+        relatedType = filteredType;
+        relDirection = 'IN';
+      }
+    }
   }
   return [
     thisType,
@@ -3064,21 +3049,6 @@ const decideRelationFilterMetadata = ({
   ];
 };
 
-const decideRelationTypeDirection = (schemaType, relationTypeDirective) => {
-  let fromType = relationTypeDirective.from;
-  let toType = relationTypeDirective.to;
-  let relDirection = 'OUT';
-  if (fromType !== toType) {
-    if (schemaType && schemaType.name === toType) {
-      const temp = fromType;
-      fromType = toType;
-      toType = temp;
-      relDirection = 'IN';
-    }
-  }
-  return [fromType, toType, relDirection];
-};
-
 const buildRelationPredicate = ({
   rootIsRelationType,
   parentFieldName,

test/helpers/tck/filterTck.md

@@ -2350,7 +2350,7 @@ MATCH (`person`:`Person`) WHERE (EXISTS((`person`)-[:WORKS_AT]->(:Company)) AND
 MATCH (`person`:`Person`) WHERE (`person`.name = $filter.name) AND (EXISTS((`person`)-[:WORKS_AT]->(:Company)) AND ALL(`company` IN [(`person`)-[:WORKS_AT]->(`_company`:Company) | `_company`] WHERE (`company`.name = $filter.company.name))) RETURN `person` { .name ,company: head([(`person`)-[:`WORKS_AT`]->(`person_company`:`Company`) WHERE (`person_company`.name = $1_filter.name) AND (((`person_company`.founded.year = $1_filter.founded.year))) | `person_company` { .name }]) } AS `person`
 ```
 
-### Nested filter on relationship type field
+### Nested filter on relationship type field (filter outgoing)
 
 ```graphql
 {
@@ -2374,6 +2374,28 @@ MATCH (`person`:`Person`) WHERE (`person`.name = $filter.name) AND (EXISTS((`per
 MATCH (`person`:`Person`) WHERE (`person`.name = $filter.name) RETURN `person` { .name ,employmentHistory: [(`person`)-[`person_employmentHistory_relation`:`WORKED_AT`]->(:`Company`) WHERE (`person_employmentHistory_relation`.role = $1_filter.role) AND (ALL(`person_filter_company` IN [(`person`)-[`person_employmentHistory_relation`]->(`_company`:Company) | `_company`] WHERE (`person_filter_company`.name = $1_filter.Company.name))) | person_employmentHistory_relation {start: { year: `person_employmentHistory_relation`.start.year },Company: head([(:`Person`)-[`person_employmentHistory_relation`]->(`person_employmentHistory_Company`:`Company`) | person_employmentHistory_Company { .name }]) }] } AS `person`
 ```
 
+### Nested filter on relationship type field (filter incoming)
+
+```graphql
+{
+  Company(filter: { name: "Neo4j" }) {
+    name
+    employeeHistory(filter: { role: "Developer", Person: { name: "jane" } }) {
+      start {
+        year
+      }
+      Person {
+        name
+      }
+    }
+  }
+}
+```
+
+```cypher
+MATCH (`company`:`Company`) WHERE (`company`.name = $filter.name) RETURN `company` { .name ,employeeHistory: [(`company`)<-[`company_employeeHistory_relation`:`WORKED_AT`]-(:`Person`) WHERE (`company_employeeHistory_relation`.role = $1_filter.role) AND (ALL(`company_filter_person` IN [(`company`)<-[`company_employeeHistory_relation`]-(`_person`:Person) | `_person`] WHERE (`company_filter_person`.name = $1_filter.Person.name))) | company_employeeHistory_relation {start: { year: `company_employeeHistory_relation`.start.year },Person: head([(:`Company`)<-[`company_employeeHistory_relation`]-(`company_employeeHistory_Person`:`Person`) | company_employeeHistory_Person { .name }]) }] } AS `company`
+```
+
 ### Nested filters on reflexive relationship type field
 
 ```graphql