Aggregated queries #1

packages/twenty-front/tsconfig.build.json

@@ -18,5 +18,5 @@
     "src/**/*.d.ts",
     "src/**/*.ts",
     "src/**/*.tsx"
-  ]
+, "../twenty-server/src/utils/is-uuid.ts", "../twenty-server/src/utils/is-uuid.utils.spec.ts"  ]
 }

packages/twenty-front/tsconfig.dev.json

@@ -9,5 +9,5 @@
     "src/**/*.d.ts",
     "src/**/*.ts",
     "src/**/*.tsx"
-  ]
+, "../twenty-server/src/utils/is-uuid.ts", "../twenty-server/src/utils/is-uuid.utils.spec.ts"  ]
 }

packages/twenty-front/tsconfig.spec.json

@@ -15,5 +15,5 @@
     "tsup.config.ts",
     "tsup.ui.index.tsx",
     "vite.config.ts"
-  ]
+, "../twenty-server/src/utils/is-uuid.utils.spec.ts"  ]
 }

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-selected-fields/graphql-selected-fields.parser.ts

@@ -33,12 +33,18 @@ export class GraphqlQuerySelectedFieldsParser {
       relations: {},
     };
 
+    const hasEdges = Object.keys(graphqlSelectedFields).includes('edges');
+
     for (const [fieldKey, fieldValue] of Object.entries(
       graphqlSelectedFields,
     )) {
+      if (hasEdges && fieldKey !== 'edges') {
+        continue;
+      }
       if (this.shouldNotParseField(fieldKey)) {
         continue;
       }
+
       if (this.isConnectionField(fieldKey, fieldValue)) {
         const subResult = this.parse(fieldValue, fieldMetadataMap);
 
@@ -83,9 +89,7 @@ export class GraphqlQuerySelectedFieldsParser {
   }
 
   private shouldNotParseField(fieldKey: string): boolean {
-    return ['__typename', 'totalCount', 'pageInfo', 'cursor'].includes(
-      fieldKey,
-    );
+    return ['__typename', 'cursor'].includes(fieldKey);
   }
 
   private parseCompositeField(

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/resolvers/graphql-query-find-many-resolver.service.ts

@@ -1,7 +1,7 @@
 import { Injectable } from '@nestjs/common';
 
-import { isDefined } from 'class-validator';
 import graphqlFields from 'graphql-fields';
+import { SelectQueryBuilder } from 'typeorm';
 
 import { ResolverService } from 'src/engine/api/graphql/graphql-query-runner/interfaces/resolver-service.interface';
 import {
@@ -13,6 +13,7 @@ import {
 import { IConnection } from 'src/engine/api/graphql/workspace-query-runner/interfaces/connection.interface';
 import { WorkspaceQueryRunnerOptions } from 'src/engine/api/graphql/workspace-query-runner/interfaces/query-runner-option.interface';
 import { FindManyResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
+import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 
 import { QUERY_MAX_RECORDS } from 'src/engine/api/graphql/graphql-query-runner/constants/query-max-records.constant';
 import {
@@ -27,8 +28,14 @@ import {
   getCursor,
   getPaginationInfo,
 } from 'src/engine/api/graphql/graphql-query-runner/utils/cursors.util';
+import {
+  AggregationField,
+  getAvailableAggregationsFromObjectFields,
+} from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
 import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
+import { isDefined } from 'src/utils/is-defined';
+import { isUuid } from 'src/utils/is-uuid';
 
 @Injectable()
 export class GraphqlQueryFindManyResolverService
@@ -85,8 +92,6 @@ export class GraphqlQueryFindManyResolverService
     );
     const isForwardPagination = !isDefined(args.before);
 
-    const limit = args.first ?? args.last ?? QUERY_MAX_RECORDS;
-
     const withDeletedCountQueryBuilder =
       graphqlQueryParser.applyDeletedAtToBuilder(
         withFilterCountQueryBuilder,
@@ -139,12 +144,30 @@ export class GraphqlQueryFindManyResolverService
       args.filter ?? ({} as Filter),
     );
 
+    const selectedAggregatedFields = this.getSelectedAggregatedFields({
+      objectFields: Object.values(
+        Object.fromEntries(
+          Object.entries(objectMetadataMapItem.fields).filter(
+            ([key, _value]) => !isUuid(key), // remove objectMetadataMapItem fields duplicates
+          ),
+        ),
+      ),
+      selectedFields,
+    });
+
+    this.addSelectedAggregatedFieldsQueriesToQueryBuilder({
+      selectedAggregatedFields,
+      queryBuilder: withDeletedQueryBuilder,
+    });
+
+    const limit = args.first ?? args.last ?? QUERY_MAX_RECORDS;
+
     const nonFormattedObjectRecords = await withDeletedQueryBuilder
       .take(limit + 1)
-      .getMany();
+      .getRawAndEntities();
 
     const objectRecords = formatResult(
-      nonFormattedObjectRecords,
+      nonFormattedObjectRecords.entities,
       objectMetadataMapItem,
       objectMetadataMap,
     );
@@ -186,7 +209,12 @@ export class GraphqlQueryFindManyResolverService
       hasPreviousPage,
     });
 
-    return result;
+    const aggregatedFieldsResults = this.extractAggregatedFieldsResults({
+      selectedAggregatedFields,
+      rawObjectRecords: nonFormattedObjectRecords.raw,
+    });
+
+    return { ...result, ...aggregatedFieldsResults };
   }
 
   async validate<Filter extends RecordFilter>(
@@ -230,4 +258,64 @@ export class GraphqlQueryFindManyResolverService
       );
     }
   }
+
+  private addSelectedAggregatedFieldsQueriesToQueryBuilder = ({
+    selectedAggregatedFields,
+    queryBuilder,
+  }: {
+    selectedAggregatedFields: AggregationField[];
+    queryBuilder: SelectQueryBuilder<any>;
+  }) => {
+    selectedAggregatedFields.forEach((aggregatedField) => {
+      const [[aggregatedFieldName, aggregatedFieldDetails]] =
+        Object.entries(aggregatedField);
+      const operation = aggregatedFieldDetails.aggregationOperation;
+      const fieldName = aggregatedFieldDetails.fromField;
+
+      queryBuilder.addSelect(
+        `${operation}("${fieldName}") OVER()`,
+        `${aggregatedFieldName}`,
+      );
+    });
+  };
+
+  private getSelectedAggregatedFields = ({
+    objectFields,
+    selectedFields,
+  }: {
+    objectFields: FieldMetadataInterface[];
+    selectedFields: any[];
+  }) => {
+    const allAggregatedFields =
+      getAvailableAggregationsFromObjectFields(objectFields);
+
+    return allAggregatedFields.reduce(
+      (acc, aggregatedField) => {
+        const aggregatedFieldName = Object.keys(aggregatedField)[0];
+
+        if (!Object.keys(selectedFields).includes(aggregatedFieldName))
+          return acc;
+
+        return [...acc, aggregatedField];
+      },
+      [] as typeof allAggregatedFields,
+    );
+  };
+
+  private extractAggregatedFieldsResults = ({
+    selectedAggregatedFields,
+    rawObjectRecords,
+  }: {
+    selectedAggregatedFields: AggregationField[];
+    rawObjectRecords: any[];
+  }) => {
+    return selectedAggregatedFields.reduce((acc, aggregatedField) => {
+      const aggregatedFieldName = Object.keys(aggregatedField)[0];
+
+      return {
+        ...acc,
+        [aggregatedFieldName]: rawObjectRecords[0][aggregatedFieldName],
+      };
+    }, {});
+  };
 }

packages/twenty-server/src/engine/api/graphql/workspace-query-runner/interfaces/query-runner-option.interface.ts

@@ -13,8 +13,8 @@ export interface WorkspaceQueryRunnerOptions {
   authContext: AuthContext;
   info: GraphQLResolveInfo;
   objectMetadataItem: ObjectMetadataInterface;
-  fieldMetadataCollection: FieldMetadataInterface[];
-  objectMetadataCollection: ObjectMetadataInterface[];
+  fieldMetadataCollection: FieldMetadataInterface[]; // Legacy
+  objectMetadataCollection: ObjectMetadataInterface[]; // Legacy
   objectMetadataMap: ObjectMetadataMap;
   objectMetadataMapItem: ObjectMetadataMapItem;
 }

packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/factories/connection-type-definition.factory.ts

@@ -5,13 +5,14 @@ import { GraphQLFieldConfigMap, GraphQLInt, GraphQLObjectType } from 'graphql';
 import { WorkspaceBuildSchemaOptions } from 'src/engine/api/graphql/workspace-schema-builder/interfaces/workspace-build-schema-optionts.interface';
 import { ObjectMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/object-metadata.interface';
 
+import { getAvailableAggregationsFromObjectFields } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';
 import { pascalCase } from 'src/utils/pascal-case';
 
+import { ConnectionTypeFactory } from './connection-type.factory';
 import {
   ObjectTypeDefinition,
   ObjectTypeDefinitionKind,
 } from './object-type-definition.factory';
-import { ConnectionTypeFactory } from './connection-type.factory';
 
 export enum ConnectionTypeDefinitionKind {
   Edge = 'Edge',
@@ -43,7 +44,25 @@ export class ConnectionTypeDefinitionFactory {
     objectMetadata: ObjectMetadataInterface,
     options: WorkspaceBuildSchemaOptions,
   ): GraphQLFieldConfigMap<any, any> {
-    const fields: GraphQLFieldConfigMap<any, any> = {};
+    const fields: GraphQLFieldConfigMap<any, any> = Object.assign(
+      {},
+      ...getAvailableAggregationsFromObjectFields(objectMetadata.fields).map(
+        (agg) => {
+          const [
+            [
+              key,
+              {
+                aggregationOperation: _aggregationOperation,
+                fromField: _fromField,
+                ...rest
+              },
+            ],
+          ] = Object.entries(agg);
+
+          return { [key]: rest };
+        },
+      ),
+    );
 
     fields.edges = {
       type: this.connectionTypeFactory.create(

packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util.ts

@@ -0,0 +1,94 @@
+import { GraphQLISODateTime } from '@nestjs/graphql';
+
+import { GraphQLFloat, GraphQLString } from 'graphql';
+
+import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
+
+import { FieldMetadataType } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+import { capitalize } from 'src/utils/capitalize';
+
+enum AGGREGATION_OPERATIONS {
+  min = 'MIN',
+  max = 'MAX',
+  avg = 'AVG',
+  sum = 'SUM',
+}
+
+type AggregationValue = {
+  type: typeof GraphQLString;
+  description: string;
+  fromField: string;
+  aggregationOperation: AGGREGATION_OPERATIONS;
+};
+
+export type AggregationField = {
+  [key: string]: AggregationValue;
+};
+
+export const getAvailableAggregationsFromObjectFields = (
+  fields: FieldMetadataInterface[],
+): AggregationField[] => {
+  return fields.reduce<Array<Record<string, any>>>((acc, field) => {
+    if (field.type === FieldMetadataType.DATE_TIME) {
+      return [
+        ...acc,
+        {
+          [`min${capitalize(field.name)}`]: {
+            type: GraphQLISODateTime,
+            description: `Oldest date contained in the field ${field.name}`,
+            fromField: field.name,
+            aggregationOperation: AGGREGATION_OPERATIONS.min,
+          },
+        },
+        {
+          [`max${capitalize(field.name)}`]: {
+            type: GraphQLISODateTime,
+            description: `Most recent date contained in the field ${field.name}`,
+            fromField: field.name,
+            aggregationOperation: AGGREGATION_OPERATIONS.max,
+          },
+        },
+      ];
+    }
+
+    if (field.type === FieldMetadataType.NUMBER) {
+      return [
+        ...acc,
+        {
+          [`min${capitalize(field.name)}`]: {
+            type: GraphQLFloat,
+            description: `Minimum value contained in the field ${field.name}`,
+            fromField: field.name,
+            aggregationOperation: AGGREGATION_OPERATIONS.min,
+          },
+        },
+        {
+          [`max${capitalize(field.name)}`]: {
+            type: GraphQLFloat,
+            description: `Maximum value contained in the field ${field.name}`,
+            fromField: field.name,
+            aggregationOperation: AGGREGATION_OPERATIONS.max,
+          },
+        },
+        {
+          [`avg${capitalize(field.name)}`]: {
+            type: GraphQLFloat,
+            description: `Average value contained in the field ${field.name}`,
+            fromField: field.name,
+            aggregationOperation: AGGREGATION_OPERATIONS.avg,
+          },
+        },
+        {
+          [`sum${capitalize(field.name)}`]: {
+            type: GraphQLFloat,
+            description: `Sum of amounts contained in the field ${field.name}`,
+            fromField: field.name,
+            aggregationOperation: AGGREGATION_OPERATIONS.sum,
+          },
+        },
+      ];
+    }
+
+    return acc;
+  }, []);
+};

packages/twenty-server/src/engine/api/graphql/workspace-schema.factory.ts

@@ -85,6 +85,7 @@ export class WorkspaceSchemaFactory {
       authContext.workspace.id,
       currentCacheVersion,
     );
+
     let usedScalarNames =
       await this.workspaceCacheStorageService.getGraphQLUsedScalarNames(
         authContext.workspace.id,

packages/twenty-server/src/utils/is-uuid.ts

@@ -0,0 +1,14 @@
+export const isUuid = (value: unknown): boolean => {
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  if (value.length !== 36) {
+    return false;
+  }
+
+  const uuidRegex =
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+  return uuidRegex.test(value);
+};