[groupBy] Load record within groups (without relations) (#15307)

First step of https://github.com/twentyhq/core-team-issues/issues/1726.
I will handle relations in another PR.
Another ticket is planned to allow for sorting among the records.

When querying records we have set the number of maximum groups to 50,
and of maximum records par group to 10.

<img width="1283" height="798" alt="image"
src="https://github.com/user-attachments/assets/7ffc9805-d715-4017-8030-4f3521e6f741"
/>

packages/twenty-server/src/engine/api/graphql/workspace-resolver-builder/factories/group-by-resolver.factory.ts

@@ -1,8 +1,8 @@
 import { Injectable } from '@nestjs/common';
 
+import { isDefined } from 'class-validator';
 import graphqlFields from 'graphql-fields';
 
-import { type WorkspaceQueryRunnerOptions } from 'src/engine/api/graphql/workspace-query-runner/interfaces/query-runner-option.interface';
 import { type WorkspaceResolverBuilderFactoryInterface } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolver-builder-factory.interface';
 import {
   GroupByResolverArgs,
@@ -11,11 +11,9 @@ import {
 import { WorkspaceSchemaBuilderContext } from 'src/engine/api/graphql/workspace-schema-builder/interfaces/workspace-schema-builder-context.interface';
 
 import { CommonGroupByQueryRunnerService } from 'src/engine/api/common/common-query-runners/common-group-by-query-runner.service';
-import { GraphqlQueryGroupByResolverService } from 'src/engine/api/graphql/graphql-query-runner/group-by/resolvers/graphql-query-group-by-resolver.service';
+import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
 import { workspaceQueryRunnerGraphqlApiExceptionHandler } from 'src/engine/api/graphql/workspace-query-runner/utils/workspace-query-runner-graphql-api-exception-handler.util';
 import { RESOLVER_METHOD_NAMES } from 'src/engine/api/graphql/workspace-resolver-builder/constants/resolver-method-names';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
-import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 
 @Injectable()
 export class GroupByResolverFactory
@@ -24,9 +22,7 @@ export class GroupByResolverFactory
   public static methodName = RESOLVER_METHOD_NAMES.GROUP_BY;
 
   constructor(
-    private readonly graphqlQueryRunnerService: GraphqlQueryGroupByResolverService,
     private readonly commonGroupByQueryRunnerService: CommonGroupByQueryRunnerService,
-    private readonly featureFlagService: FeatureFlagService,
   ) {}
 
   create(
@@ -35,37 +31,48 @@ export class GroupByResolverFactory
     const internalContext = context;
 
     return async (_source, args, _context, info) => {
-      const isCommonApiEnabled = await this.featureFlagService.isFeatureEnabled(
-        FeatureFlagKey.IS_COMMON_API_ENABLED,
-        internalContext.authContext.workspace?.id as string,
-      );
+      const selectedFields = graphqlFields(info);
 
-      if (isCommonApiEnabled) {
-        const selectedFields = graphqlFields(info);
+      const shouldIncludeRecords =
+        isDefined(selectedFields.edges?.node) &&
+        Object.keys(selectedFields.edges?.node).length > 0;
 
-        try {
-          return await this.commonGroupByQueryRunnerService.execute(
-            { ...args, selectedFields },
-            internalContext,
+      try {
+        const typeORMObjectRecordsParser =
+          new ObjectRecordsToGraphqlConnectionHelper(
+            internalContext.objectMetadataMaps,
           );
-        } catch (error) {
-          workspaceQueryRunnerGraphqlApiExceptionHandler(error);
-        }
+
+        const results = await this.commonGroupByQueryRunnerService.execute(
+          { ...args, selectedFields, includeRecords: shouldIncludeRecords },
+          internalContext,
+        );
+
+        const formattedResults = results.map((group) => {
+          const formattedRecords = typeORMObjectRecordsParser.createConnection({
+            objectRecords: group.records ?? [],
+            objectName:
+              internalContext.objectMetadataItemWithFieldMaps.nameSingular,
+            objectRecordsAggregatedValues: {},
+            selectedAggregatedFields: {},
+            take: group.records?.length || 0,
+            totalCount: Number(group.totalCount ?? 0),
+            hasNextPage: false,
+            hasPreviousPage: false,
+          });
+
+          const { _records, ...groupWithoutRecords } = group;
+
+          return {
+            ...groupWithoutRecords,
+            ...formattedRecords,
+          };
+        });
+
+        return formattedResults;
+      } catch (error) {
+        workspaceQueryRunnerGraphqlApiExceptionHandler(error);
       }
-
-      const options: WorkspaceQueryRunnerOptions = {
-        authContext: internalContext.authContext,
-        info,
-        objectMetadataMaps: internalContext.objectMetadataMaps,
-        objectMetadataItemWithFieldMaps:
-          internalContext.objectMetadataItemWithFieldMaps,
-      };
-
-      return await this.graphqlQueryRunnerService.execute(
-        args,
-        options,
-        GroupByResolverFactory.methodName,
-      );
     };
   }
 }