Implement groupBy resolver (with orderBy, without viewId) (#14690)

Closes https://github.com/twentyhq/core-team-issues/issues/248?issue=twentyhq%7Ccore-team-issues%7C1543 In this PR - Implementation of groupBy resolver, without pagination, without viewId parameter - introduction of new GqlInputTypeDefinitionKind `OrderByWithGroupBy` which differs from `OrderBy` as it should use aggregations as order by conditions (e.g.: OrderByWithGroupBy should use avgEmployees and not employees which does not make sense) - Minor refacto of all orderBy expressions to use orderBy signature with `OrderByCondition` which is usable for both groupBy queries and non-groupBy queries. groupBy queries differ because their orderBy conditions are based on aggregatedFields (such as avgEmployees) for which we can't use the same orderBy signature <img width="728" height="216" alt="Capture d’écran 2025-09-24 à 15 07 14" src="https://github.com/user-attachments/assets/aa5c0875-cf38-4d4b-be70-f4d64da77a41" /> - Minor refacto to add table name in aggregates expressions `(AVG("employees") -> AVG("company"."employees")` to keep having the table names in the orderBy expression as we already had. Since we use common utils for orderBy and aggregates on findMany this change also impacts findMany queries with aggregates. It also impacts field permission check where we extract the name of the selected fields to check permission on, so I also updated that (see `extractColumnNamesFromAggregateExpression`)
2025-09-24 18:00:55 +02:00
parent d477db261a
commit 8d78032357
13 changed files with 530 additions and 345 deletions
@@ -4,4 +4,5 @@ export enum GqlInputTypeDefinitionKind {
  Filter = 'Filter',
  OrderBy = 'OrderBy',
  GroupBy = 'GroupBy',
+  OrderByWithGroupBy = 'OrderByWithGroupBy',
 }
@@ -4,6 +4,7 @@ import { ObjectMetadataCreateGqlInputTypeGenerator } from 'src/engine/api/graphq
 import { ObjectMetadataFilterGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/filter-input/object-metadata-filter-gql-input-type.generator';
 import { ObjectMetadataGroupByGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/group-by-input/object-metadata-group-by-gql-input-type.generator';
 import { ObjectMetadataOrderByGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/order-by-input/object-metadata-order-by-gql-input-type.generator';
+import { ObjectMetadataOrderByWithGroupByGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/order-by-input/object-metadata-order-by-with-group-by-gql-input-type.generator';
 import { ObjectMetadataUpdateGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/update-input/object-metadata-update-gql-input-type.generator';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';

@@ -14,6 +15,7 @@ export class ObjectMetadataGqlInputTypeGenerator {
    private readonly objectMetadataUpdateGqlInputTypeGenerator: ObjectMetadataUpdateGqlInputTypeGenerator,
    private readonly objectMetadataFilterGqlInputTypeGenerator: ObjectMetadataFilterGqlInputTypeGenerator,
    private readonly objectMetadataOrderByGqlInputTypeGenerator: ObjectMetadataOrderByGqlInputTypeGenerator,
+    private readonly objectMetadataOrderByWithGroupByGqlInputTypeGenerator: ObjectMetadataOrderByWithGroupByGqlInputTypeGenerator,
    private readonly objectMetadataGroupByGqlInputTypeGenerator: ObjectMetadataGroupByGqlInputTypeGenerator,
  ) {}

@@ -27,9 +29,12 @@ export class ObjectMetadataGqlInputTypeGenerator {
    this.objectMetadataFilterGqlInputTypeGenerator.buildAndStore(
      objectMetadata,
    );
-    this.objectMetadataOrderByGqlInputTypeGenerator.buildAndStore(
+    this.objectMetadataOrderByGqlInputTypeGenerator.buildAndStore({
      objectMetadata,
-    );
+    });
+    this.objectMetadataOrderByWithGroupByGqlInputTypeGenerator.buildAndStore({
+      objectMetadata,
+    });
    this.objectMetadataGroupByGqlInputTypeGenerator.buildAndStore(
      objectMetadata,
    );
@@ -34,7 +34,11 @@ export class ObjectMetadataOrderByGqlInputTypeGenerator {
    private readonly typeMapperService: TypeMapperService,
  ) {}

-  public buildAndStore(objectMetadata: ObjectMetadataEntity) {
+  public buildAndStore({
+    objectMetadata,
+  }: {
+    objectMetadata: ObjectMetadataEntity;
+  }) {
    const inputType = new GraphQLInputObjectType({
      name: `${pascalCase(objectMetadata.nameSingular)}${GqlInputTypeDefinitionKind.OrderBy.toString()}Input`,
      description: objectMetadata.description,
@@ -0,0 +1,183 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import {
+  GraphQLInputFieldConfigMap,
+  GraphQLInputObjectType,
+  isInputObjectType,
+} from 'graphql';
+import { isDefined } from 'twenty-shared/utils';
+
+import { GqlInputTypeDefinitionKind } from 'src/engine/api/graphql/workspace-schema-builder/enums/gql-input-type-definition-kind.enum';
+import { RelationFieldMetadataGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/relation-field-metadata-gql-type.generator';
+import {
+  TypeMapperService,
+  TypeOptions,
+} from 'src/engine/api/graphql/workspace-schema-builder/services/type-mapper.service';
+import { GqlTypesStorage } from 'src/engine/api/graphql/workspace-schema-builder/storages/gql-types.storage';
+import { computeFieldInputTypeOptions } from 'src/engine/api/graphql/workspace-schema-builder/utils/compute-field-input-type-options.util';
+import { computeCompositeFieldInputTypeKey } from 'src/engine/api/graphql/workspace-schema-builder/utils/compute-stored-gql-type-key-utils/compute-composite-field-input-type-key.util';
+import { computeObjectMetadataInputTypeKey } from 'src/engine/api/graphql/workspace-schema-builder/utils/compute-stored-gql-type-key-utils/compute-object-metadata-input-type.util';
+import { getAvailableAggregationsFromObjectFields } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';
+import { isFieldMetadataRelationOrMorphRelation } from 'src/engine/api/graphql/workspace-schema-builder/utils/is-field-metadata-relation-or-morph-relation.utils';
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { pascalCase } from 'src/utils/pascal-case';
+
+@Injectable()
+export class ObjectMetadataOrderByWithGroupByGqlInputTypeGenerator {
+  private readonly logger = new Logger(
+    ObjectMetadataOrderByWithGroupByGqlInputTypeGenerator.name,
+  );
+  constructor(
+    private readonly gqlTypesStorage: GqlTypesStorage,
+    private readonly relationFieldMetadataGqlInputTypeGenerator: RelationFieldMetadataGqlInputTypeGenerator,
+    private readonly typeMapperService: TypeMapperService,
+  ) {}
+
+  public buildAndStore({
+    objectMetadata,
+  }: {
+    objectMetadata: ObjectMetadataEntity;
+  }) {
+    const inputType = new GraphQLInputObjectType({
+      name: `${pascalCase(objectMetadata.nameSingular)}${GqlInputTypeDefinitionKind.OrderByWithGroupBy.toString()}Input`,
+      description: objectMetadata.description,
+      fields: () => this.generateFields(objectMetadata),
+    }) as GraphQLInputObjectType;
+
+    const key = computeObjectMetadataInputTypeKey(
+      objectMetadata.nameSingular,
+      GqlInputTypeDefinitionKind.OrderByWithGroupBy,
+    );
+
+    this.gqlTypesStorage.addGqlType(key, inputType);
+  }
+
+  private generateFields(
+    objectMetadata: ObjectMetadataEntity,
+  ): GraphQLInputFieldConfigMap {
+    const allGeneratedFields: GraphQLInputFieldConfigMap = {};
+
+    for (const fieldMetadata of objectMetadata.fields) {
+      fieldMetadata.isNullable = true;
+
+      const typeOptions = computeFieldInputTypeOptions(
+        fieldMetadata,
+        GqlInputTypeDefinitionKind.OrderBy,
+      );
+
+      let generatedFields;
+
+      if (isFieldMetadataRelationOrMorphRelation(fieldMetadata)) {
+        generatedFields =
+          this.relationFieldMetadataGqlInputTypeGenerator.generateSimpleRelationFieldOrderByInputType(
+            {
+              fieldMetadata,
+              typeOptions,
+            },
+          );
+      } else if (isCompositeFieldMetadataType(fieldMetadata.type)) {
+        generatedFields = this.generateCompositeFieldOrderByInputType(
+          fieldMetadata,
+          typeOptions,
+        );
+      } else {
+        generatedFields = this.generateAtomicFieldOrderByInputType(
+          fieldMetadata,
+          typeOptions,
+        );
+      }
+
+      Object.assign(allGeneratedFields, generatedFields);
+    }
+
+    return allGeneratedFields;
+  }
+
+  private generateCompositeFieldOrderByInputType(
+    fieldMetadata: FieldMetadataEntity,
+    typeOptions: TypeOptions,
+  ) {
+    const key = computeCompositeFieldInputTypeKey(
+      fieldMetadata.type,
+      GqlInputTypeDefinitionKind.OrderBy,
+    );
+
+    const compositeType = this.gqlTypesStorage.getGqlTypeByKey(key);
+
+    if (!isDefined(compositeType) || !isInputObjectType(compositeType)) {
+      const message = `Could not find a GraphQL input type for ${fieldMetadata.type} field metadata`;
+
+      this.logger.error(message, {
+        fieldMetadata,
+        typeOptions,
+      });
+      throw new Error(message);
+    }
+
+    const aggregations =
+      this.generateAggregateFieldOrderByInputType(fieldMetadata);
+
+    return aggregations;
+  }
+
+  private generateAtomicFieldOrderByInputType(
+    fieldMetadata: FieldMetadataEntity,
+    typeOptions: TypeOptions,
+  ) {
+    const orderByType = this.typeMapperService.mapToOrderByType(
+      fieldMetadata.type,
+    );
+
+    if (!isDefined(orderByType)) {
+      const message = `Could not find a GraphQL input type for ${fieldMetadata.type} field metadata`;
+
+      this.logger.error(message, {
+        fieldMetadata,
+        typeOptions,
+      });
+      throw new Error(message);
+    }
+
+    const aggregations =
+      this.generateAggregateFieldOrderByInputType(fieldMetadata);
+
+    return aggregations;
+  }
+
+  private generateAggregateFieldOrderByInputType(
+    fieldMetadata: FieldMetadataEntity,
+  ) {
+    const aggregations = getAvailableAggregationsFromObjectFields([
+      fieldMetadata,
+    ]);
+
+    let result: GraphQLInputFieldConfigMap = {};
+
+    for (const [aggregationKey, aggregationDetails] of Object.entries(
+      aggregations,
+    )) {
+      const orderByWithGroupByType =
+        this.typeMapperService.mapToOrderByWithGroupByType(
+          aggregations[aggregationKey].aggregateOperation,
+        );
+
+      if (!isDefined(orderByWithGroupByType)) {
+        const message = `Could not find a GraphQL input type for ${aggregations.type} aggregation`;
+
+        this.logger.error(message, {
+          aggregations,
+        });
+        throw new Error(message);
+      }
+
+      result[aggregationKey] = {
+        type: orderByWithGroupByType,
+        description: aggregationDetails.description,
+      };
+    }
+
+    return result;
+  }
+}
@@ -11,6 +11,7 @@ import { ObjectMetadataGroupByGqlInputTypeGenerator } from 'src/engine/api/graph
 import { ObjectMetadataGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/object-metadata-gql-input-type.generator';
 import { CompositeFieldMetadataOrderByGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/order-by-input/composite-field-metadata-order-by-gql-input-type.generator';
 import { ObjectMetadataOrderByGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/order-by-input/object-metadata-order-by-gql-input-type.generator';
+import { ObjectMetadataOrderByWithGroupByGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/order-by-input/object-metadata-order-by-with-group-by-gql-input-type.generator';
 import { RelationConnectGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/relation-connect-gql-input-type.generator';
 import { RelationFieldMetadataGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/relation-field-metadata-gql-type.generator';
 import { CompositeFieldMetadataUpdateGqlInputTypeGenerator } from 'src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/update-input/composite-field-metadata-update-gql-input-type.generator';
@@ -45,6 +46,7 @@ export const workspaceSchemaBuilderTypeGenerators = [
  ObjectMetadataFilterGqlInputTypeGenerator,
  ObjectMetadataOrderByGqlInputTypeGenerator,
  ObjectMetadataGroupByGqlInputTypeGenerator,
+  ObjectMetadataOrderByWithGroupByGqlInputTypeGenerator,
  CompositeFieldMetadataGqlObjectTypeGenerator,
  ObjectMetadataGqlObjectTypeGenerator,
  RelationConnectGqlInputTypeGenerator,
@@ -22,6 +22,7 @@ import {
  NumberDataType,
 } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';

+import { AggregateOperations } from 'src/engine/api/graphql/graphql-query-runner/constants/aggregate-operations.constant';
 import { OrderByDirectionType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/enum';
 import {
  ArrayFilterType,
@@ -168,6 +169,27 @@ export class TypeMapperService {
    return typeOrderByMapping.get(fieldMetadataType);
  }

+  mapToOrderByWithGroupByType(
+    aggregationType: AggregateOperations,
+  ): GraphQLInputType | undefined {
+    const typeOrderByMapping = new Map<AggregateOperations, GraphQLInputType>([
+      [AggregateOperations.SUM, OrderByDirectionType],
+      [AggregateOperations.COUNT, OrderByDirectionType],
+      [AggregateOperations.COUNT_UNIQUE_VALUES, OrderByDirectionType],
+      [AggregateOperations.COUNT_EMPTY, OrderByDirectionType],
+      [AggregateOperations.COUNT_NOT_EMPTY, OrderByDirectionType],
+      [AggregateOperations.COUNT_TRUE, OrderByDirectionType],
+      [AggregateOperations.COUNT_FALSE, OrderByDirectionType],
+      [AggregateOperations.PERCENTAGE_EMPTY, OrderByDirectionType],
+      [AggregateOperations.PERCENTAGE_NOT_EMPTY, OrderByDirectionType],
+      [AggregateOperations.MIN, OrderByDirectionType],
+      [AggregateOperations.MAX, OrderByDirectionType],
+      [AggregateOperations.AVG, OrderByDirectionType],
+    ]);
+
+    return typeOrderByMapping.get(aggregationType);
+  }
+
  applyTypeOptions<T extends GraphQLType = GraphQLType>(
    typeRef: T,
    options: TypeOptions,
@@ -169,7 +169,7 @@ export const getResolverArgs = (
          isNullable: true,
        },
        orderBy: {
-          kind: GqlInputTypeDefinitionKind.OrderBy,
+          kind: GqlInputTypeDefinitionKind.OrderByWithGroupBy,
          isNullable: true,
          isArray: true,
        },