Merge remote-tracking branch 'origin/aggregation-6' into aggregation-7

.changeset/hot-bikes-complain.md

@@ -0,0 +1,32 @@
+---
+"@neo4j/graphql": patch
+---
+
+Add count fields in aggregations with support for nodes and edges count:
+
+```graphql
+query {
+    moviesConnection {
+        aggregate {
+            count {
+                nodes
+            }
+        }
+    }
+}
+```
+
+```graphql
+query {
+    movies {
+        actorsConnection {
+            aggregate {
+                count {
+                    nodes
+                    edges
+                }
+            }
+        }
+    }
+}
+```

.changeset/hot-windows-whisper.md

@@ -2,7 +2,7 @@
 "@neo4j/graphql": minor
 ---
 
-Add aggregate fieldd in connection:
+Add aggregate field in connection:
 
 ```graphql
 query {

.changeset/sixty-steaks-reflect.md

@@ -2,4 +2,4 @@
 "@neo4j/graphql": patch
 ---
 
-Deprecate aggrgation fields (e.g `actedInAggregate`) in favor of the field `aggregate` inside the connection (e.g `actedInConnection -> aggregate`)
+Deprecate aggregation fields (e.g `actedInAggregate`) in favor of the field `aggregate` inside the connection (e.g `actedInConnection -> aggregate`)

packages/graphql/CHANGELOG.md

@@ -339,6 +339,29 @@
 
 - [#5837](https://github.com/neo4j/graphql/pull/5837) [`721691a`](https://github.com/neo4j/graphql/commit/721691a84eaa34996c0c97edb7ede1ae4775dd2f) Thanks [@MacondoExpress](https://github.com/MacondoExpress)! - Added a validation rule to avoid defining fields as lists of nullable elements, as Neo4j does not support this.
 
+## 6.3.1
+
+### Patch Changes
+
+- [#5952](https://github.com/neo4j/graphql/pull/5952) [`4e14680`](https://github.com/neo4j/graphql/commit/4e1468076bbd23cdd9156b039de1d03bbc68942c) Thanks [@angrykoala](https://github.com/angrykoala)! - Add `addVersionPrefix` to `cypherQueryOptions` in context to add a Cypher version with `CYPHER` before each query:
+
+    ```js
+    {
+        cypherQueryOptions: {
+            addVersionPrefix: true,
+        },
+    }
+    ```
+
+    This prepends all Cypher queries with a `CYPHER [version]` statement:
+
+    ```cypher
+    CYPHER 5
+    MATCH (this:Movie)
+    WHERE this.title = $param0
+    RETURN this { .title } AS this
+    ```
+
 ## 6.3.0
 
 ### Minor Changes

packages/graphql/package.json

@@ -60,7 +60,7 @@
         "jest": "29.7.0",
         "jest-extended": "4.0.2",
         "jwks-rsa": "3.1.0",
-        "koa": "2.15.3",
+        "koa": "2.15.4",
         "koa-jwt": "4.0.4",
         "koa-router": "13.0.1",
         "mock-jwks": "1.0.10",

packages/graphql/src/graphql/objects/CartesianPoint.ts

@@ -41,7 +41,7 @@ export const CartesianPoint = new GraphQLObjectType({
         },
         srid: {
             type: new GraphQLNonNull(GraphQLInt),
-            resolve: (source, args, context, info) => numericalResolver(source, args, context, info),
+            resolve: numericalResolver,
         },
     },
 });

packages/graphql/src/graphql/objects/Point.ts

@@ -44,7 +44,7 @@ export const Point = new GraphQLObjectType({
         },
         srid: {
             type: new GraphQLNonNull(GraphQLInt),
-            resolve: (source, args, context, info) => numericalResolver(source, args, context, info),
+            resolve: numericalResolver,
         },
     },
 });

packages/graphql/src/schema-model/entity/model-adapters/ImplementingEntityOperations.ts

@@ -131,10 +131,15 @@ export class ImplementingEntityOperations<T extends InterfaceEntityAdapter | Con
         return `${this.entityAdapter.name}ImplementationsSubscriptionWhere`;
     }
 
+    /** @deprecated use `getAggregateFieldTypename` instead */
     public getAggregationFieldTypename(): string {
         return this.aggregateTypeNames.selection;
     }
 
+    public getAggregateFieldTypename(): string {
+        return this.aggregateTypeNames.selection;
+    }
+
     public get rootTypeFieldNames(): RootTypeFieldNames {
         return {
             connection: `${this.entityAdapter.plural}Connection`,

packages/graphql/src/schema-model/relationship/model-adapters/RelationshipBaseOperations.ts

@@ -38,7 +38,10 @@ export abstract class RelationshipBaseOperations<T extends RelationshipAdapter |
 
     protected abstract get edgePrefix(): string;
 
-    /**Note: Required for now to infer the types without ResolveTree */
+    /**Note: Required for now to infer the types without ResolveTree
+     * @deprecated use getAggregateFieldTypename
+     *
+     */
     public getAggregationFieldTypename(nestedField?: "node" | "edge"): string {
         const nestedFieldStr = upperFirst(nestedField || "");
         const aggregationStr = nestedField ? "Aggregate" : "Aggregation";
@@ -47,6 +50,13 @@ export abstract class RelationshipBaseOperations<T extends RelationshipAdapter |
         )}${nestedFieldStr}${aggregationStr}Selection`;
     }
 
+    public getAggregateFieldTypename(nestedField?: "node" | "edge"): string {
+        const nestedFieldStr = upperFirst(nestedField || "");
+        return `${this.relationship.source.name}${this.relationship.target.name}${upperFirst(
+            this.relationship.name
+        )}${nestedFieldStr}AggregateSelection`;
+    }
+
     public getTargetTypePrettyName(): string {
         if (this.relationship.isList) {
             return `[${this.relationship.target.name}!]${!this.relationship.isNullable ? "!" : ""}`;

packages/graphql/src/schema/aggregations/aggregation-types-mapper.ts

@@ -17,6 +17,7 @@
  * limitations under the License.
  */
 
+import { GraphQLInt, GraphQLNonNull } from "graphql";
 import type { ObjectTypeComposer, SchemaComposer } from "graphql-compose";
 import type { Subgraph } from "../../classes/Subgraph";
 import { numericalResolver } from "../resolvers/field/numerical";
@@ -25,16 +26,56 @@ export class AggregationTypesMapper {
     private readonly aggregationSelectionTypes: Record<string, ObjectTypeComposer<unknown, unknown>>;
 
     private readonly subgraph: Subgraph | undefined;
+    private readonly composer: SchemaComposer;
 
     constructor(composer: SchemaComposer, subgraph?: Subgraph) {
         this.subgraph = subgraph;
         this.aggregationSelectionTypes = this.getOrCreateAggregationSelectionTypes(composer);
+        this.composer = composer;
     }
 
     public getAggregationType(typeName: string): ObjectTypeComposer<unknown, unknown> | undefined {
         return this.aggregationSelectionTypes[typeName];
     }
 
+    /** Top level count */
+    public getCountType(): ObjectTypeComposer {
+        const countFieldName = "Count";
+        const directives: string[] = this.subgraph ? [this.subgraph.getFullyQualifiedDirectiveName("shareable")] : [];
+        return this.composer.getOrCreateOTC(countFieldName, (countField) => {
+            countField.addFields({
+                nodes: {
+                    type: new GraphQLNonNull(GraphQLInt),
+                    resolve: numericalResolver,
+                },
+            });
+            for (const directiveName of directives) {
+                countField.setDirectiveByName(directiveName);
+            }
+        });
+    }
+
+    /** Nested count */
+    public getCountConnectionType(): ObjectTypeComposer {
+        const countFieldName = "CountConnection";
+        const directives: string[] = this.subgraph ? [this.subgraph.getFullyQualifiedDirectiveName("shareable")] : [];
+        return this.composer.getOrCreateOTC(countFieldName, (countField) => {
+            countField.addFields({
+                nodes: {
+                    type: new GraphQLNonNull(GraphQLInt),
+                    resolve: numericalResolver,
+                },
+                edges: {
+                    type: new GraphQLNonNull(GraphQLInt),
+                    resolve: numericalResolver,
+                },
+            });
+            for (const directiveName of directives) {
+                countField.setDirectiveByName(directiveName);
+            }
+        });
+    }
+
     private getOrCreateAggregationSelectionTypes(
         composer: SchemaComposer
     ): Record<string, ObjectTypeComposer<unknown, unknown>> {

packages/graphql/src/schema/aggregations/field-aggregation-composer.ts

@@ -79,6 +79,15 @@ export class FieldAggregationComposer {
             );
         }
 
+        this.composer.createObjectTC({
+            name: relationshipAdapter.operations.getAggregateFieldTypename(),
+            fields: {
+                count: this.aggregationTypesMapper.getCountConnectionType().NonNull,
+                ...(aggregateSelectionNode ? { node: aggregateSelectionNode } : {}),
+                ...(aggregateSelectionEdge ? { edge: aggregateSelectionEdge } : {}),
+            },
+        });
+
         return this.composer.createObjectTC({
             name: relationshipAdapter.operations.getAggregationFieldTypename(),
             fields: {

packages/graphql/src/schema/generation/aggregate-types.ts

@@ -91,26 +91,33 @@ function createConnectionAggregate({
     composer: SchemaComposer;
     features: Neo4jFeaturesSettings | undefined;
 }): ObjectTypeComposer {
-    const aggregateNode = composer.createObjectTC({
-        name: entityAdapter.operations.aggregateTypeNames.node,
-        fields: {
-            count: {
-                type: new GraphQLNonNull(GraphQLInt),
-                resolve: numericalResolver,
-                args: {},
-            },
-        },
-        directives: graphqlDirectivesToCompose(propagatedDirectives),
-    });
-    aggregateNode.addFields(makeAggregableFields({ entityAdapter, aggregationTypesMapper, features }));
+    const aggregableFields = makeAggregableFields({ entityAdapter, aggregationTypesMapper, features });
+    let aggregateNode: ObjectTypeComposer | undefined;
+    const hasNodeAggregateFields = Object.keys(aggregableFields).length > 0;
+    if (hasNodeAggregateFields) {
+        aggregateNode = composer.createObjectTC({
+            name: entityAdapter.operations.aggregateTypeNames.node,
+            fields: {},
+            directives: graphqlDirectivesToCompose(propagatedDirectives),
+        });
+        aggregateNode.addFields(aggregableFields);
+    }
 
-    return composer.createObjectTC({
+    const connectionAggregate = composer.createObjectTC({
         name: entityAdapter.operations.aggregateTypeNames.connection,
         fields: {
-            node: aggregateNode.NonNull,
+            count: aggregationTypesMapper.getCountType().NonNull,
         },
         directives: graphqlDirectivesToCompose(propagatedDirectives),
     });
+
+    if (aggregateNode) {
+        connectionAggregate.addFields({
+            node: aggregateNode.NonNull,
+        });
+    }
+
+    return connectionAggregate;
 }
 
 function makeAggregableFields({

packages/graphql/src/schema/generation/connection-object-type.ts

@@ -51,7 +51,7 @@ export function withConnectionObjectType({
 
     if (relationshipAdapter.isAggregable() && !isTargetUnion && !isSourceInterface) {
         connectionObjectType.addFields({
-            aggregate: composer.getOTC(relationshipAdapter.operations.getAggregationFieldTypename()).NonNull,
+            aggregate: composer.getOTC(relationshipAdapter.operations.getAggregateFieldTypename()).NonNull,
         });
     }
 

packages/graphql/src/translate/queryAST/ast/fields/aggregation-fields/AggregationAttributeField.ts

@@ -67,7 +67,7 @@ export class AggregationAttributeField extends AggregationField {
                 .return(projection);
         }
 
-        return new Cypher.Return([this.getAggregationExpr(target), returnVar]);
+        return new Cypher.With(target).distinct().return([this.getAggregationExpr(target), returnVar]);
     }
 
     private createAggregationExpr(target: Cypher.Variable | Cypher.Property): Cypher.Expr {

packages/graphql/src/translate/queryAST/ast/fields/aggregation-fields/CountField.ts

@@ -24,10 +24,22 @@ import { AggregationField } from "./AggregationField";
 
 export class CountField extends AggregationField {
     private entity: Entity;
+    public edgeVar: Cypher.Variable | undefined;
 
-    constructor({ alias, entity }: { alias: string; entity: Entity }) {
+    private countFields: { nodes: boolean; edges: boolean };
+
+    constructor({
+        alias,
+        entity,
+        fields,
+    }: {
+        alias: string;
+        entity: Entity;
+        fields: { nodes: boolean; edges: boolean };
+    }) {
         super(alias);
         this.entity = entity;
+        this.countFields = fields;
     }
 
     public getChildren(): QueryASTNode[] {
@@ -39,10 +51,24 @@ export class CountField extends AggregationField {
     }
 
     public getAggregationExpr(variable: Cypher.Variable): Cypher.Expr {
-        return Cypher.count(variable);
+        return Cypher.count(variable).distinct();
     }
 
     public getAggregationProjection(target: Cypher.Variable, returnVar: Cypher.Variable): Cypher.Clause {
-        return new Cypher.Return([this.getAggregationExpr(target), returnVar]);
+        const resultMap = new Cypher.Map();
+
+        if (this.countFields.nodes) {
+            resultMap.set("nodes", this.getAggregationExpr(target));
+        }
+        if (this.countFields.edges) {
+            if (!this.edgeVar) {
+                throw new Error(
+                    "Edge variable not defined in Count field. This is likely a bug with the GraphQL library."
+                );
+            }
+            resultMap.set("edges", this.getAggregationExpr(this.edgeVar));
+        }
+
+        return new Cypher.Return([resultMap, returnVar]);
     }
 }

packages/graphql/src/translate/queryAST/ast/fields/aggregation-fields/DeprecatedCountField.ts

@@ -0,0 +1,48 @@
+/*
+ * 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 { Entity } from "../../../../../schema-model/entity/Entity";
+import type { QueryASTNode } from "../../QueryASTNode";
+import { AggregationField } from "./AggregationField";
+
+export class DeprecatedCountField extends AggregationField {
+    private entity: Entity;
+
+    constructor({ alias, entity }: { alias: string; entity: Entity }) {
+        super(alias);
+        this.entity = entity;
+    }
+
+    public getChildren(): QueryASTNode[] {
+        return [];
+    }
+
+    public getProjectionField(variable: Cypher.Variable): Record<string, Cypher.Expr> {
+        return { [this.alias]: variable };
+    }
+
+    public getAggregationExpr(variable: Cypher.Variable): Cypher.Expr {
+        return Cypher.count(variable);
+    }
+
+    public getAggregationProjection(target: Cypher.Variable, returnVar: Cypher.Variable): Cypher.Clause {
+        return new Cypher.Return([this.getAggregationExpr(target), returnVar]);
+    }
+}