[Feature Branch] Aggregation 7

.changeset/funny-tools-arrive.md

@@ -0,0 +1,15 @@
+---
+"@neo4j/graphql": patch
+---
+
+Following the changes of moving aggregations inside the connection fields, 
+the previous aggregations filters outside the connection filters are now deprecated.
+
+The flag `aggregationFiltersOutsideConnection` has been added to the excludeDeprecatedFields setting.
+
+```ts
+const neoSchema = new Neo4jGraphQL({
+    typeDefs,
+    features: { excludeDeprecatedFields: { aggregationFiltersOutsideConnection: true } },
+});
+```

.changeset/gorgeous-goats-design.md

@@ -0,0 +1,25 @@
+---
+"@neo4j/graphql": minor
+---
+
+Aggregations filters are moved to the connection input field.
+
+**Current aggregation filters:**
+
+```graphql
+{
+    posts(where: { likesConnection: { aggregate: { node: { someInt: { average: { eq: 10 } } } } } }) {
+        content
+    }
+}
+```
+
+**Deprecated aggregation filters:**
+
+```graphql
+{
+    posts(where: { likesAggregate: { node: { someInt: { average: { eq: 10 } } } } }) {
+        content
+    }
+}
+```

.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

@@ -0,0 +1,20 @@
+---
+"@neo4j/graphql": minor
+---
+
+Add aggregate field in connection:
+
+```graphql
+query {
+    moviesConnection {
+        aggregate {
+            node {
+                count
+                int {
+                    longest
+                }
+            }
+        }
+    }
+}
+```

.changeset/silent-phones-sort.md

@@ -0,0 +1,31 @@
+---
+"@neo4j/graphql": minor
+---
+
+The aggregation filter `count` now supports both, nodes and relationships.
+
+**Count filter on nodes:**
+
+```graphql
+{
+    posts(where: { likesConnection: { aggregate: { count: { nodes: { eq: 2 } } } } }) {
+        title
+        likes {
+            name
+        }
+    }
+}
+```
+
+**Count filter on edges:**
+
+```graphql
+{
+    posts(where: { likesConnection: { aggregate: { count: { edges: { eq: 2 } } } } }) {
+        title
+        likes {
+            name
+        }
+    }
+}
+```

.changeset/sixty-steaks-reflect.md

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

.changeset/soft-socks-count.md

@@ -0,0 +1,22 @@
+---
+"@neo4j/graphql": patch
+---
+
+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
+```

.changeset/thin-goats-begin.md

@@ -0,0 +1,25 @@
+---
+"@neo4j/graphql": patch
+---
+
+Deprecated old aggregate operations:
+
+```graphql
+query {
+    moviesAggregate {
+        count
+        rating {
+            min
+        }
+    }
+}
+```
+
+These fields can be completely removed from the schema with the new flag `deprecatedAggregateOperations`:
+
+```js
+const neoSchema = new Neo4jGraphQL({
+    typeDefs,
+    features: { excludeDeprecatedFields: { deprecatedAggregateOperations: true } },
+});
+```

packages/graphql/src/classes/Neo4jDatabaseInfo.ts

@@ -29,7 +29,7 @@ export class Neo4jDatabaseInfo {
     public edition: Neo4jEdition | undefined;
 
     constructor(version: string, edition?: Neo4jEdition) {
-        // Quick hack to support CalVar
+        // Quick hack to support CalVer
         version = version.replace(/\.0([0-9]+)/, ".$1");
         this.version = this.toSemVer(version);
         this.rawVersion = version;

packages/graphql/src/graphql/input-objects/generic-aggregation-filters/CountScalarAggregationFilters.ts

@@ -0,0 +1,29 @@
+/*
+ * 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 { GraphQLInputObjectType } from "graphql";
+import { IntScalarFilters } from "../generic-operators/IntScalarFilters";
+
+export const ConnectionAggregationCountFilterInput = new GraphQLInputObjectType({
+    name: "ConnectionAggregationCountFilterInput",
+    fields: {
+        nodes: { type: IntScalarFilters },
+        edges: { type: IntScalarFilters },
+    },
+});

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

@@ -33,6 +33,8 @@ export type RootTypeFieldNames = {
 type AggregateTypeNames = {
     selection: string;
     input: string;
+    connection: string;
+    node: string;
 };
 
 type MutationResponseTypeNames = {
@@ -129,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`,
@@ -148,6 +155,8 @@ export class ImplementingEntityOperations<T extends InterfaceEntityAdapter | Con
         return {
             selection: `${this.entityAdapter.name}AggregateSelection`,
             input: `${this.entityAdapter.name}AggregateSelectionInput`,
+            connection: `${this.entityAdapter.name}Aggregate`,
+            node: `${this.entityAdapter.name}AggregateNode`,
         };
     }
 

packages/graphql/src/schema-model/relationship/model-adapters/RelationshipAdapter.test.ts

@@ -141,7 +141,7 @@ describe("RelationshipAdapter", () => {
 
     test("should parse selectable", () => {
         const relationshipAdapter = userAdapter.relationships.get("accounts");
-        expect(relationshipAdapter?.isAggregable()).toBeTrue();
+        expect(relationshipAdapter?.isAggregable()).toBeFalse();
         expect(relationshipAdapter?.isReadable()).toBeFalse();
     });
 });

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

@@ -186,6 +186,14 @@ export class RelationshipAdapter {
     }
 
     public isAggregable(): boolean {
+        if (!this.aggregate) {
+            return false;
+        }
+
+        if (this.target instanceof UnionEntityAdapter || this.source instanceof InterfaceEntityAdapter) {
+            return false;
+        }
+
         return this.annotations.selectable?.onAggregate !== false;
     }
 

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 ? "!" : ""}`;
@@ -115,12 +125,16 @@ export abstract class RelationshipBaseOperations<T extends RelationshipAdapter |
     public getUpdateConnectionInputTypename(ifUnionRelationshipTargetEntity?: ConcreteEntityAdapter): string {
         return `${this.prefixForTypename}${ifUnionRelationshipTargetEntity?.name || ""}UpdateConnectionInput`;
     }
-
+    // Legacy typename superseded by getUpdateConnectionInputTypename, which is slightly different type - contains nodes for edges/nodes
     public get aggregateInputTypeName(): string {
         return `${this.prefixForTypename}AggregateInput`;
     }
 
-    public get aggregateTypeName(): string {
+    public get connectionAggregateInputTypeName(): string {
+        return `${this.prefixForTypename}ConnectionAggregateInput`;
+    }
+
+    public get aggregateFieldName(): string {
         return `${this.relationship.name}Aggregate`;
     }