group by root input

Author: angrykoala

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

@@ -185,6 +185,10 @@ export class AttributeAdapter {
         );
     }
 
+    canGroupBy(): boolean {
+        return Boolean(this.annotations.groupBy);
+    }
+
     isAggregationWhereField(): boolean {
         if (
             this.typeHelper.isList() ||

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

@@ -174,6 +174,10 @@ export class ConcreteEntityAdapter {
         return Array.from(this.attributes.values()).filter((attribute) => attribute.isAggregableField());
     }
 
+    public get groupByFields(): AttributeAdapter[] {
+        return Array.from(this.attributes.values()).filter((attribute) => attribute.canGroupBy());
+    }
+
     public get aggregationWhereFields(): AttributeAdapter[] {
         return Array.from(this.attributes.values()).filter((attribute) => attribute.isAggregationWhereField());
     }

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

@@ -55,6 +55,14 @@ export class ConcreteEntityOperations extends ImplementingEntityOperations<Concr
         return `${this.entityAdapter.name}Edge`;
     }
 
+    public getConnectionGroupByInputTypename(): string {
+        return `${this.entityAdapter.name}GroupByInput`;
+    }
+
+    public getConnectionGroupByTypename(): string {
+        return `${this.entityAdapter.name}GroupByInput`;
+    }
+
     public get rootTypeFieldNames(): RootTypeFieldNames {
         return {
             ...super.rootTypeFieldNames,

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

@@ -122,6 +122,10 @@ export abstract class RelationshipBaseOperations<T extends RelationshipAdapter |
         return `${this.prefixForTypenameWithInheritance}${ifUnionRelationshipTargetEntity?.name || ""}ConnectionWhere`;
     }
 
+    public getConnectionGroupByTypename(): string {
+        return `${this.prefixForTypenameWithInheritance}GroupBy`;
+    }
+
     public getUpdateConnectionInputTypename(ifUnionRelationshipTargetEntity?: ConcreteEntityAdapter): string {
         return `${this.prefixForTypename}${ifUnionRelationshipTargetEntity?.name || ""}UpdateConnectionInput`;
     }

packages/graphql/src/schema/generation/augment-object-or-interface.ts

@@ -106,6 +106,7 @@ export function augmentObjectOrInterfaceTypeWithConnectionField(
             (directive) => directive.name.value === DEPRECATED
         )
     );
+
     const composeNodeArgs: ObjectTypeComposerArgumentConfigMapDefinition = {
         where: makeConnectionWhereInputType({
             relationshipAdapter,
@@ -139,7 +140,7 @@ export function augmentObjectOrInterfaceTypeWithConnectionField(
             resolve: (source: any, args: ConnectionQueryArgs, _ctx: any, info: GraphQLResolveInfo) => {
                 return connectionFieldResolver({
                     connectionFieldName: relationshipAdapter.operations.connectionFieldName,
-                args,
+                    args,
                     info,
                     source,
                 });

packages/graphql/src/schema/generation/connection-group-by.ts

@@ -0,0 +1,49 @@
+/*
+ * 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 type { InputTypeComposer, SchemaComposer } from "graphql-compose";
+import type { ConcreteEntityAdapter } from "../../schema-model/entity/model-adapters/ConcreteEntityAdapter";
+
+export function makeConnectionGroupByInputType({
+    entityAdapter,
+    composer,
+}: {
+    entityAdapter: ConcreteEntityAdapter;
+    composer: SchemaComposer;
+}): InputTypeComposer | undefined {
+    const typeName = entityAdapter.operations.getConnectionGroupByInputTypename();
+    if (composer.has(typeName)) {
+        return composer.getITC(typeName);
+    }
+
+    const groupByFields = entityAdapter.groupByFields;
+
+    if (groupByFields.length === 0) {
+        return undefined;
+    }
+
+    const connectionGroupByITC = composer.createInputTC(typeName);
+    for (const attribute of groupByFields) {
+        connectionGroupByITC.addFields({
+            [attribute.name]: "Boolean",
+        });
+    }
+
+    return connectionGroupByITC;
+}

packages/graphql/src/schema/resolvers/query/root-connection.ts

@@ -25,16 +25,17 @@ import {
     type GraphQLResolveInfo,
     type SelectionSetNode,
 } from "graphql";
-import type { InputTypeComposer, SchemaComposer } from "graphql-compose";
+import type { ObjectTypeComposerArgumentConfigDefinition, SchemaComposer } from "graphql-compose";
 import { PageInfo } from "../../../graphql/objects/PageInfo";
-import type { ConcreteEntityAdapter } from "../../../schema-model/entity/model-adapters/ConcreteEntityAdapter";
+import { ConcreteEntityAdapter } from "../../../schema-model/entity/model-adapters/ConcreteEntityAdapter";
 import type { InterfaceEntityAdapter } from "../../../schema-model/entity/model-adapters/InterfaceEntityAdapter";
 import { UnionEntityAdapter } from "../../../schema-model/entity/model-adapters/UnionEntityAdapter";
 import type { Neo4jGraphQLSchemaModel } from "../../../schema-model/Neo4jGraphQLSchemaModel";
 import { translateRead } from "../../../translate/translate-read";
 import { execute } from "../../../utils";
 import getNeo4jResolveTree from "../../../utils/get-neo4j-resolve-tree";
 import { isNeoInt } from "../../../utils/utils";
+import { makeConnectionGroupByInputType } from "../../generation/connection-group-by";
 import { makeSortInput } from "../../generation/sort-and-options-input";
 import { createConnectionWithEdgeProperties } from "../../pagination";
 import { graphqlDirectivesToCompose } from "../../to-compose";
@@ -120,20 +121,33 @@ export function rootConnectionResolver({
         });
     }
 
+    const args: Record<string, ObjectTypeComposerArgumentConfigDefinition> = {
+        first: isLimitRequired ? new GraphQLNonNull(GraphQLInt) : GraphQLInt,
+        after: GraphQLString,
+        where: entityAdapter.operations.whereInputTypeName,
+    };
+
     // since sort is not created when there is nothing to sort, we check for its existence
-    let sortArg: InputTypeComposer | undefined;
     if (!(entityAdapter instanceof UnionEntityAdapter)) {
-        sortArg = makeSortInput({ entityAdapter, userDefinedFieldDirectives: new Map(), composer });
+        const sortArg = makeSortInput({ entityAdapter, userDefinedFieldDirectives: new Map(), composer });
+        if (sortArg) {
+            args.sort = sortArg.NonNull.List;
+        }
+    }
+
+    if (entityAdapter instanceof ConcreteEntityAdapter) {
+        const groupBy = makeConnectionGroupByInputType({
+            composer,
+            entityAdapter,
+        });
+        if (groupBy) {
+            args.groupBy = groupBy;
+        }
     }
 
     return {
         type: rootConnection.NonNull,
         resolve,
-        args: {
-            first: isLimitRequired ? new GraphQLNonNull(GraphQLInt) : GraphQLInt,
-            after: GraphQLString,
-            where: entityAdapter.operations.whereInputTypeName,
-            ...(sortArg ? { sort: sortArg.NonNull.List } : {}),
-        },
+        args,
     };
 }

packages/graphql/tests/schema/directives/group-by.test.ts

@@ -123,6 +123,10 @@ describe("@groupBy directive", () => {
               node: Movie!
             }
 
+            input MovieGroupByInput {
+              title: Boolean
+            }
+
             \\"\\"\\"
             Fields to sort Movies by. The order in which sorts are applied is not guaranteed when specifying many fields in one MovieSort object.
             \\"\\"\\"
@@ -156,10 +160,6 @@ describe("@groupBy directive", () => {
               edges: [MovieEdge!]!
             }
 
-            input MovieGroupByInput {
-              title: Boolean
-            }
-
             type Mutation {
               createMovies(input: [MovieCreateInput!]!): CreateMoviesMutationResponse!
               deleteMovies(where: MovieWhere): DeleteInfo!
@@ -176,7 +176,7 @@ describe("@groupBy directive", () => {
 
             type Query {
               movies(limit: Int, offset: Int, sort: [MovieSort!], where: MovieWhere): [Movie!]!
-              moviesConnection(after: String, first: Int, sort: [MovieSort!], where: MovieWhere, groupBy: MovieGroupByInput): MoviesConnection!
+              moviesConnection(after: String, first: Int, groupBy: MovieGroupByInput, sort: [MovieSort!], where: MovieWhere): MoviesConnection!
             }
 
             \\"\\"\\"An enum for sorting in either ascending or descending order.\\"\\"\\"