[Feature Branch] Aggregation 6

.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/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/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/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 = {
@@ -142,10 +144,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`,
@@ -161,6 +168,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

@@ -142,7 +142,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

@@ -202,6 +202,10 @@ export class RelationshipAdapter {
     }
 
     public isAggregable(): boolean {
+        if (!this.aggregate) {
+            return false;
+        }
+
         return this.annotations.selectable?.onAggregate !== false;
     }
 

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

@@ -17,11 +17,11 @@
  * limitations under the License.
  */
 
-import type { ConcreteEntityAdapter } from "../../entity/model-adapters/ConcreteEntityAdapter";
-import { upperFirst } from "../../../utils/upper-first";
 import { isUnionEntity } from "../../../translate/queryAST/utils/is-union-entity";
-import type { RelationshipDeclarationAdapter } from "./RelationshipDeclarationAdapter";
+import { upperFirst } from "../../../utils/upper-first";
+import type { ConcreteEntityAdapter } from "../../entity/model-adapters/ConcreteEntityAdapter";
 import type { RelationshipAdapter } from "./RelationshipAdapter";
+import type { RelationshipDeclarationAdapter } from "./RelationshipDeclarationAdapter";
 
 export abstract class RelationshipBaseOperations<T extends RelationshipAdapter | RelationshipDeclarationAdapter> {
     protected constructor(protected readonly relationship: T) {}
@@ -39,7 +39,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";
@@ -48,6 +51,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 { idResolver } from "../resolvers/field/id";
@@ -26,16 +27,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

@@ -81,6 +81,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/constants.ts

@@ -18,6 +18,10 @@
  */
 
 import { DEPRECATED } from "../constants";
+import type { ConcreteEntityAdapter } from "../schema-model/entity/model-adapters/ConcreteEntityAdapter";
+import type { InterfaceEntityAdapter } from "../schema-model/entity/model-adapters/InterfaceEntityAdapter";
+import type { RelationshipAdapter } from "../schema-model/relationship/model-adapters/RelationshipAdapter";
+import type { RelationshipDeclarationAdapter } from "../schema-model/relationship/model-adapters/RelationshipDeclarationAdapter";
 
 export const DEPRECATE_IMPLICIT_EQUAL_FILTERS = {
     name: DEPRECATED,
@@ -61,7 +65,6 @@ export const DEPRECATE_OVERWRITE = {
     },
 };
 
-
 export const DEPRECATE_ID_AGGREGATION = {
     name: DEPRECATED,
     args: {
@@ -75,3 +78,21 @@ export const DEPRECATE_TYPENAME_IN = {
         reason: "The typename_IN filter is deprecated, please use the typename filter instead",
     },
 };
+
+export function DEPRECATE_AGGREGATION(entity: ConcreteEntityAdapter | InterfaceEntityAdapter) {
+    return {
+        name: DEPRECATED,
+        args: {
+            reason: `Please use the explicit field "aggregate" inside "${entity.operations.rootTypeFieldNames.connection}" instead`,
+        },
+    };
+}
+
+export function DEPRECATE_NESTED_AGGREGATION(relationship: RelationshipAdapter | RelationshipDeclarationAdapter) {
+    return {
+        name: DEPRECATED,
+        args: {
+            reason: `Please use field "aggregate" inside "${relationship.operations.connectionFieldName}" instead`,
+        },
+    };
+}

packages/graphql/src/schema/create-relationship-fields/create-relationship-fields.ts

@@ -29,6 +29,7 @@ import { RelationshipAdapter } from "../../schema-model/relationship/model-adapt
 import { RelationshipDeclarationAdapter } from "../../schema-model/relationship/model-adapters/RelationshipDeclarationAdapter";
 import type { Neo4jFeaturesSettings } from "../../types";
 import { FieldAggregationComposer } from "../aggregations/field-aggregation-composer";
+import { DEPRECATE_NESTED_AGGREGATION } from "../constants";
 import { addDirectedArgument } from "../directed-argument";
 import {
     augmentObjectOrInterfaceTypeWithConnectionField,
@@ -48,6 +49,7 @@ import { getRelationshipPropertiesTypeDescription, withObjectType } from "../gen
 import { withRelationInputType } from "../generation/relation-input";
 import { withSortInputType } from "../generation/sort-and-options-input";
 import { augmentUpdateInputTypeWithUpdateFieldInput, withUpdateInputType } from "../generation/update-input";
+import { shouldAddDeprecatedFields } from "../generation/utils";
 import { withSourceWhereInputType, withWhereInputType } from "../generation/where-input";
 import { graphqlDirectivesToCompose } from "../to-compose";
 
@@ -254,7 +256,6 @@ export function createRelationshipFields({
             return;
         }
 
-        // TODO: new way
         if (composeNode instanceof ObjectTypeComposer) {
             // make a new fn augmentObjectTypeWithAggregationField
             const fieldAggregationComposer = new FieldAggregationComposer(schemaComposer, subgraph);
@@ -271,13 +272,18 @@ export function createRelationshipFields({
             const aggregationFieldsArgs = addDirectedArgument(aggregationFieldsBaseArgs, relationshipAdapter, features);
 
             if (relationshipAdapter.aggregate) {
-                composeNode.addFields({
-                    [relationshipAdapter.operations.aggregateTypeName]: {
-                        type: aggregationTypeObject,
-                        args: aggregationFieldsArgs,
-                        directives: deprecatedDirectives,
-                    },
-                });
+                if (shouldAddDeprecatedFields(features, "deprecatedAggregateOperations")) {
+                    composeNode.addFields({
+                        [relationshipAdapter.operations.aggregateTypeName]: {
+                            type: aggregationTypeObject,
+                            args: aggregationFieldsArgs,
+                            directives:
+                                deprecatedDirectives.length > 0
+                                    ? deprecatedDirectives
+                                    : [DEPRECATE_NESTED_AGGREGATION(relationshipAdapter)],
+                        },
+                    });
+                }
             }
         }