Custom cypher scalar field filtering

.changeset/lovely-beans-grin.md

@@ -0,0 +1,5 @@
+---
+"@neo4j/graphql": minor
+---
+
+Add filtering on scalar custom cypher fields

packages/graphql/src/schema-model/attribute/model-adapters/AttributeAdapter.ts

@@ -135,8 +135,7 @@ export class AttributeAdapter {
         return (
             (this.typeHelper.isEnum() || this.typeHelper.isSpatial() || this.typeHelper.isScalar()) &&
             this.isFilterable() &&
-            !this.isCustomResolvable() &&
-            !this.isCypher()
+            !this.isCustomResolvable()
         );
     }
 

packages/graphql/src/schema/get-where-fields.ts

@@ -214,7 +214,7 @@ export function getWhereFieldsForAttributes({
             directives: deprecatedDirectives,
         };
 
-        if (shouldAddDeprecatedFields(features, "negationFilters")) {
+        if (shouldAddDeprecatedFields(features, "negationFilters") && !field.isCypher()) {
             result[`${field.name}_NOT`] = {
                 type: field.getInputTypeNames().where.pretty,
                 directives: deprecatedDirectives.length ? deprecatedDirectives : [DEPRECATE_NOT],
@@ -247,7 +247,7 @@ export function getWhereFieldsForAttributes({
             type: field.getFilterableInputTypeName(),
             directives: deprecatedDirectives,
         };
-        if (shouldAddDeprecatedFields(features, "negationFilters")) {
+        if (shouldAddDeprecatedFields(features, "negationFilters") && !field.isCypher()) {
             result[`${field.name}_NOT_IN`] = {
                 type: field.getFilterableInputTypeName(),
                 directives: deprecatedDirectives.length ? deprecatedDirectives : [DEPRECATE_NOT],

packages/graphql/src/translate/queryAST/ast/filters/property-filters/CypherFilter.ts

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Cypher from "@neo4j/cypher-builder";
+import type { AttributeAdapter } from "../../../../../schema-model/attribute/model-adapters/AttributeAdapter";
+import { createComparisonOperation } from "../../../utils/create-comparison-operator";
+import type { QueryASTContext } from "../../QueryASTContext";
+import type { QueryASTNode } from "../../QueryASTNode";
+import type { CustomCypherSelection } from "../../selection/CustomCypherSelection";
+import type { FilterOperator } from "../Filter";
+import { Filter } from "../Filter";
+import { coalesceValueIfNeeded } from "../utils/coalesce-if-needed";
+import { createDurationOperation } from "../utils/create-duration-operation";
+import { createPointOperation } from "../utils/create-point-operation";
+
+/** A property which comparison has already been parsed into a Param */
+export class CypherFilter extends Filter {
+    private returnVariable: Cypher.Variable = new Cypher.Variable();
+    private attribute: AttributeAdapter;
+    private selection: CustomCypherSelection;
+    private operator: FilterOperator;
+    protected comparisonValue: unknown;
+
+    constructor({
+        selection,
+        attribute,
+        operator,
+        comparisonValue,
+    }: {
+        selection: CustomCypherSelection;
+        attribute: AttributeAdapter;
+        operator: FilterOperator;
+        comparisonValue: unknown;
+    }) {
+        super();
+        this.selection = selection;
+        this.attribute = attribute;
+        this.operator = operator;
+        this.comparisonValue = comparisonValue;
+    }
+
+    public getChildren(): QueryASTNode[] {
+        return [this.selection];
+    }
+
+    public print(): string {
+        return `${super.print()} [${this.attribute.name}] <${this.operator}>`;
+    }
+
+    public getSubqueries(context: QueryASTContext): Cypher.Clause[] {
+        const { selection: cypherSubquery, nestedContext } = this.selection.apply(context);
+
+        const clause = Cypher.concat(
+            cypherSubquery,
+            new Cypher.Return([nestedContext.returnVariable, this.returnVariable])
+        );
+
+        return [clause];
+    }
+
+    public getPredicate(_queryASTContext: QueryASTContext): Cypher.Predicate {
+        const operation = this.createBaseOperation({
+            operator: this.operator,
+            property: this.returnVariable,
+            param: new Cypher.Param(this.comparisonValue),
+        });
+
+        return operation;
+    }
+
+    /** Returns the default operation for a given filter */
+    private createBaseOperation({
+        operator,
+        property,
+        param,
+    }: {
+        operator: FilterOperator;
+        property: Cypher.Expr;
+        param: Cypher.Expr;
+    }): Cypher.ComparisonOp {
+        const coalesceProperty = coalesceValueIfNeeded(this.attribute, property);
+
+        // This could be solved with specific a specific CypherDurationFilter but
+        // we need to use the return variable for the cypher subquery.
+        // To allow us to extend the DurationFilter class with a CypherDurationFilter class
+        // we would need to have a way to provide the return variable
+        // to the PropertyFilter's getPropertyRef method.
+        if (this.attribute.typeHelper.isDuration()) {
+            return createDurationOperation({
+                operator,
+                property: coalesceProperty,
+                param: new Cypher.Param(this.comparisonValue),
+            });
+        }
+
+        if (this.attribute.typeHelper.isSpatial()) {
+            return createPointOperation({
+                operator,
+                property: coalesceProperty,
+                param: new Cypher.Param(this.comparisonValue),
+                attribute: this.attribute,
+            });
+        }
+
+        return createComparisonOperation({ operator, property: coalesceProperty, param });
+    }
+}

packages/graphql/src/translate/queryAST/ast/filters/property-filters/DurationFilter.ts

@@ -18,38 +18,18 @@
  */
 
 import Cypher from "@neo4j/cypher-builder";
-import type { WhereOperator } from "../Filter";
+import { coalesceValueIfNeeded } from "../utils/coalesce-if-needed";
+import { createDurationOperation } from "../utils/create-duration-operation";
 import { PropertyFilter } from "./PropertyFilter";
 
 export class DurationFilter extends PropertyFilter {
-    protected getOperation(prop: Cypher.Property): Cypher.ComparisonOp {
-        // NOTE: this may not be needed
-        if (this.operator === "EQ") {
-            return Cypher.eq(prop, new Cypher.Param(this.comparisonValue));
-        }
-        return this.createDurationOperation({
+    protected getOperation(prop: Cypher.Expr): Cypher.ComparisonOp {
+        const coalesceProperty = coalesceValueIfNeeded(this.attribute, prop);
+
+        return createDurationOperation({
             operator: this.operator,
-            property: prop,
+            property: coalesceProperty,
             param: new Cypher.Param(this.comparisonValue),
         });
     }
-
-    private createDurationOperation({
-        operator,
-        property,
-        param,
-    }: {
-        operator: WhereOperator | "EQ";
-        property: Cypher.Expr;
-        param: Cypher.Expr;
-    }) {
-        const variable = Cypher.plus(Cypher.datetime(), param);
-        const propertyRef = Cypher.plus(Cypher.datetime(), property);
-
-        return this.createBaseOperation({
-            operator,
-            property: propertyRef,
-            param: variable,
-        });
-    }
 }

packages/graphql/src/translate/queryAST/ast/filters/property-filters/PointFilter.ts

@@ -18,72 +18,16 @@
  */
 
 import Cypher from "@neo4j/cypher-builder";
-import type { AttributeAdapter } from "../../../../../schema-model/attribute/model-adapters/AttributeAdapter";
-import type { WhereOperator } from "../Filter";
+import { createPointOperation } from "../utils/create-point-operation";
 import { PropertyFilter } from "./PropertyFilter";
 
 export class PointFilter extends PropertyFilter {
     protected getOperation(prop: Cypher.Property): Cypher.ComparisonOp {
-        return this.createPointOperation({
+        return createPointOperation({
             operator: this.operator || "EQ",
             property: prop,
             param: new Cypher.Param(this.comparisonValue),
             attribute: this.attribute,
         });
     }
-
-    private createPointOperation({
-        operator,
-        property,
-        param,
-        attribute,
-    }: {
-        operator: WhereOperator | "EQ";
-        property: Cypher.Expr;
-        param: Cypher.Param;
-        attribute: AttributeAdapter;
-    }): Cypher.ComparisonOp {
-        const pointDistance = this.createPointDistanceExpression(property, param);
-        const distanceRef = param.property("distance");
-
-        switch (operator) {
-            case "LT":
-                return Cypher.lt(pointDistance, distanceRef);
-            case "LTE":
-                return Cypher.lte(pointDistance, distanceRef);
-            case "GT":
-                return Cypher.gt(pointDistance, distanceRef);
-            case "GTE":
-                return Cypher.gte(pointDistance, distanceRef);
-            case "DISTANCE":
-                return Cypher.eq(pointDistance, distanceRef);
-            case "EQ": {
-                if (attribute.typeHelper.isList()) {
-                    const pointList = this.createPointListComprehension(param);
-                    return Cypher.eq(property, pointList);
-                }
-
-                return Cypher.eq(property, Cypher.point(param));
-            }
-            case "IN": {
-                const pointList = this.createPointListComprehension(param);
-                return Cypher.in(property, pointList);
-            }
-            case "INCLUDES":
-                return Cypher.in(Cypher.point(param), property);
-            default:
-                throw new Error(`Invalid operator ${operator}`);
-        }
-    }
-
-    private createPointListComprehension(param: Cypher.Param): Cypher.ListComprehension {
-        const comprehensionVar = new Cypher.Variable();
-        const mapPoint = Cypher.point(comprehensionVar);
-        return new Cypher.ListComprehension(comprehensionVar, param).map(mapPoint);
-    }
-
-    private createPointDistanceExpression(property: Cypher.Expr, param: Cypher.Param): Cypher.Function {
-        const nestedPointRef = param.property("point");
-        return Cypher.point.distance(property, Cypher.point(nestedPointRef));
-    }
 }

packages/graphql/src/translate/queryAST/ast/filters/property-filters/PropertyFilter.ts

@@ -19,14 +19,15 @@
 
 import Cypher from "@neo4j/cypher-builder";
 import type { AttributeAdapter } from "../../../../../schema-model/attribute/model-adapters/AttributeAdapter";
+import { InterfaceEntityAdapter } from "../../../../../schema-model/entity/model-adapters/InterfaceEntityAdapter";
+import type { RelationshipAdapter } from "../../../../../schema-model/relationship/model-adapters/RelationshipAdapter";
+import { hasTarget } from "../../../utils/context-has-target";
 import { createComparisonOperation } from "../../../utils/create-comparison-operator";
 import type { QueryASTContext } from "../../QueryASTContext";
 import type { QueryASTNode } from "../../QueryASTNode";
 import type { FilterOperator } from "../Filter";
 import { Filter } from "../Filter";
-import { hasTarget } from "../../../utils/context-has-target";
-import type { RelationshipAdapter } from "../../../../../schema-model/relationship/model-adapters/RelationshipAdapter";
-import { InterfaceEntityAdapter } from "../../../../../schema-model/entity/model-adapters/InterfaceEntityAdapter";
+import { coalesceValueIfNeeded } from "../utils/coalesce-if-needed";
 
 export class PropertyFilter extends Filter {
     protected attribute: AttributeAdapter;
@@ -130,7 +131,7 @@ export class PropertyFilter extends Filter {
     /** Returns the operation for a given filter.
      * To be overridden by subclasses
      */
-    protected getOperation(prop: Cypher.Property | Cypher.Case): Cypher.ComparisonOp {
+    protected getOperation(prop: Cypher.Expr): Cypher.ComparisonOp {
         return this.createBaseOperation({
             operator: this.operator,
             property: prop,
@@ -148,20 +149,11 @@ export class PropertyFilter extends Filter {
         property: Cypher.Expr;
         param: Cypher.Expr;
     }): Cypher.ComparisonOp {
-        const coalesceProperty = this.coalesceValueIfNeeded(property);
+        const coalesceProperty = coalesceValueIfNeeded(this.attribute, property);
 
         return createComparisonOperation({ operator, property: coalesceProperty, param });
     }
 
-    protected coalesceValueIfNeeded(expr: Cypher.Expr): Cypher.Expr {
-        if (this.attribute.annotations.coalesce) {
-            const value = this.attribute.annotations.coalesce.value;
-            const literal = new Cypher.Literal(value);
-            return Cypher.coalesce(expr, literal);
-        }
-        return expr;
-    }
-
     private getNullPredicate(propertyRef: Cypher.Property | Cypher.Case): Cypher.Predicate {
         if (this.isNot) {
             return Cypher.isNotNull(propertyRef);

packages/graphql/src/translate/queryAST/ast/filters/utils/coalesce-if-needed.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Cypher from "@neo4j/cypher-builder";
+import type { AttributeAdapter } from "../../../../../schema-model/attribute/model-adapters/AttributeAdapter";
+
+export function coalesceValueIfNeeded(attribute: AttributeAdapter, expr: Cypher.Expr): Cypher.Expr {
+    if (attribute.annotations.coalesce) {
+        const value = attribute.annotations.coalesce.value;
+        const literal = new Cypher.Literal(value);
+        return Cypher.coalesce(expr, literal);
+    }
+    return expr;
+}