Common api - findMany query (#15004)

Done in this PR : - simplify rest input parsing by removing metadata validation (for filter and orderBy - to add in common) (1st commit) - simplify result getter handlers signature (array of objectRecord only for input) closes https://github.com/twentyhq/core-team-issues/issues/1614 closes https://github.com/twentyhq/core-team-issues/issues/1615 closes https://github.com/twentyhq/core-team-issues/issues/1616
2025-10-13 14:48:50 +02:00
parent 4c7e8444cf
commit fc7304bc5a
67 changed files with 1291 additions and 349 deletions
@@ -3,11 +3,10 @@ import { Inject, Injectable } from '@nestjs/common';
 import { isDefined } from 'twenty-shared/utils';

 import { WorkspaceAuthContext } from 'src/engine/api/common/interfaces/workspace-auth-context.interface';
-import { type ObjectRecord } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
-import { type IConnection } from 'src/engine/api/graphql/workspace-query-runner/interfaces/connection.interface';
-import { type IEdge } from 'src/engine/api/graphql/workspace-query-runner/interfaces/edge.interface';
+import { ObjectRecord } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';

 import { CommonSelectedFieldsHandler } from 'src/engine/api/common/common-args-handlers/common-query-selected-fields/common-selected-fields.handler';
+import { CommonResultGettersService } from 'src/engine/api/common/common-result-getters/common-result-getters.service';
 import { CommonQueryNames } from 'src/engine/api/common/types/common-query-args.type';
 import { OBJECTS_WITH_SETTINGS_PERMISSIONS_REQUIREMENTS } from 'src/engine/api/graphql/graphql-query-runner/constants/objects-with-settings-permissions-requirements';
 import { ProcessNestedRelationsHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations.helper';
@@ -30,13 +29,7 @@ import { WorkspacePermissionsCacheService } from 'src/engine/metadata-modules/wo
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';

@Injectable()
-export abstract class CommonBaseQueryRunnerService<
-  Response extends
-    | ObjectRecord
-    | ObjectRecord[]
-    | IConnection<ObjectRecord, IEdge<ObjectRecord>>
-    | IConnection<ObjectRecord, IEdge<ObjectRecord>>[],
-> {
+export abstract class CommonBaseQueryRunnerService {
  @Inject()
  protected readonly workspaceQueryHookService: WorkspaceQueryHookService;
  @Inject()
@@ -57,6 +50,8 @@ export abstract class CommonBaseQueryRunnerService<
  protected readonly selectedFieldsHandler: CommonSelectedFieldsHandler;
  @Inject()
  protected readonly workspacePermissionsCacheService: WorkspacePermissionsCacheService;
+  @Inject()
+  protected readonly commonResultGettersService: CommonResultGettersService;

  public async prepareQueryRunnerContext({
    authContext,
@@ -107,18 +102,19 @@ export abstract class CommonBaseQueryRunnerService<
    objectMetadataItemWithFieldMaps,
    objectMetadataMaps,
  }: {
-    results: Response;
+    results: ObjectRecord[];
    operationName: CommonQueryNames;
    authContext: WorkspaceAuthContext;
    objectMetadataItemWithFieldMaps: ObjectMetadataItemWithFieldMaps;
    objectMetadataMaps: ObjectMetadataMaps;
-  }) {
-    const resultWithGetters = await this.queryResultGettersFactory.create(
-      results,
-      objectMetadataItemWithFieldMaps,
-      authContext.workspace.id,
-      objectMetadataMaps,
-    );
+  }): Promise<ObjectRecord[]> {
+    const resultWithGetters =
+      await this.commonResultGettersService.processQueryResult(
+        results,
+        objectMetadataItemWithFieldMaps.id,
+        objectMetadataMaps,
+        authContext.workspace.id,
+      );

    await this.workspaceQueryHookService.executePostQueryHooks(
      authContext,
@@ -0,0 +1,286 @@
+import { Injectable } from '@nestjs/common';
+
+import { isDefined } from 'class-validator';
+import { QUERY_MAX_RECORDS } from 'twenty-shared/constants';
+import { FindOptionsRelations, ObjectLiteral } from 'typeorm';
+
+import { WorkspaceAuthContext } from 'src/engine/api/common/interfaces/workspace-auth-context.interface';
+import {
+  ObjectRecord,
+  ObjectRecordFilter,
+  ObjectRecordOrderBy,
+  OrderByDirection,
+} from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
+
+import { CommonBaseQueryRunnerService } from 'src/engine/api/common/common-query-runners/common-base-query-runner.service';
+import {
+  CommonQueryRunnerException,
+  CommonQueryRunnerExceptionCode,
+} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
+import { CommonPageInfo } from 'src/engine/api/common/types/common-page-info.type';
+import {
+  CommonQueryNames,
+  FindManyQueryArgs,
+} from 'src/engine/api/common/types/common-query-args.type';
+import { getPageInfo } from 'src/engine/api/common/utils/get-page-info.util';
+import { isWorkspaceAuthContext } from 'src/engine/api/common/utils/is-workspace-auth-context.util';
+import { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
+import { ProcessAggregateHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper';
+import { buildColumnsToSelect } from 'src/engine/api/graphql/graphql-query-runner/utils/build-columns-to-select';
+import { getCursor } from 'src/engine/api/graphql/graphql-query-runner/utils/cursors.util';
+import { computeCursorArgFilter } from 'src/engine/api/utils/compute-cursor-arg-filter.utils';
+import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
+import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
+import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
+
+@Injectable()
+export class CommonFindManyQueryRunnerService extends CommonBaseQueryRunnerService {
+  async run({
+    args,
+    authContext: toValidateAuthContext,
+    objectMetadataMaps,
+    objectMetadataItemWithFieldMaps,
+  }: {
+    args: FindManyQueryArgs;
+    authContext: AuthContext;
+    objectMetadataMaps: ObjectMetadataMaps;
+    objectMetadataItemWithFieldMaps: ObjectMetadataItemWithFieldMaps;
+  }): Promise<{
+    records: ObjectRecord[];
+    aggregatedValues: Record<string, number>;
+    totalCount: number;
+    pageInfo: CommonPageInfo;
+  }> {
+    this.validate(args);
+    const authContext = toValidateAuthContext;
+
+    if (!isWorkspaceAuthContext(authContext)) {
+      throw new CommonQueryRunnerException(
+        'Invalid auth context',
+        CommonQueryRunnerExceptionCode.INVALID_AUTH_CONTEXT,
+      );
+    }
+
+    const {
+      workspaceDataSource,
+      repository,
+      roleId,
+      shouldBypassPermissionChecks,
+    } = await this.prepareQueryRunnerContext({
+      authContext,
+      objectMetadataItemWithFieldMaps,
+    });
+
+    const processedArgs = await this.processQueryArgs({
+      authContext,
+      objectMetadataItemWithFieldMaps,
+      args,
+    });
+
+    const queryBuilder = repository.createQueryBuilder(
+      objectMetadataItemWithFieldMaps.nameSingular,
+    );
+
+    const aggregateQueryBuilder = queryBuilder.clone();
+
+    let appliedFilters = processedArgs.filter ?? ({} as ObjectRecordFilter);
+
+    const commonQueryParser = new GraphqlQueryParser(
+      objectMetadataItemWithFieldMaps,
+      objectMetadataMaps,
+    );
+
+    commonQueryParser.applyFilterToBuilder(
+      aggregateQueryBuilder,
+      objectMetadataItemWithFieldMaps.nameSingular,
+      appliedFilters,
+    );
+
+    commonQueryParser.applyDeletedAtToBuilder(
+      aggregateQueryBuilder,
+      appliedFilters,
+    );
+
+    const orderByWithIdCondition = [
+      ...(processedArgs.orderBy ?? []),
+      { id: OrderByDirection.AscNullsFirst },
+    ] as ObjectRecordOrderBy;
+
+    const isForwardPagination = !isDefined(processedArgs.before);
+
+    const cursor = getCursor(processedArgs);
+
+    if (cursor) {
+      const cursorArgFilter = computeCursorArgFilter(
+        cursor,
+        orderByWithIdCondition,
+        objectMetadataItemWithFieldMaps,
+        isForwardPagination,
+      );
+
+      appliedFilters = (processedArgs.filter
+        ? {
+            and: [processedArgs.filter, { or: cursorArgFilter }],
+          }
+        : { or: cursorArgFilter }) as unknown as ObjectRecordFilter;
+    }
+
+    commonQueryParser.applyFilterToBuilder(
+      queryBuilder,
+      objectMetadataItemWithFieldMaps.nameSingular,
+      appliedFilters,
+    );
+
+    commonQueryParser.applyOrderToBuilder(
+      queryBuilder,
+      orderByWithIdCondition,
+      objectMetadataItemWithFieldMaps.nameSingular,
+      isForwardPagination,
+    );
+
+    commonQueryParser.applyDeletedAtToBuilder(queryBuilder, appliedFilters);
+
+    ProcessAggregateHelper.addSelectedAggregatedFieldsQueriesToQueryBuilder({
+      selectedAggregatedFields: processedArgs.selectedFieldsResult.aggregate,
+      queryBuilder: aggregateQueryBuilder,
+      objectMetadataNameSingular: objectMetadataItemWithFieldMaps.nameSingular,
+    });
+
+    const limit =
+      processedArgs.first ?? processedArgs.last ?? QUERY_MAX_RECORDS;
+
+    const columnsToSelect = buildColumnsToSelect({
+      select: processedArgs.selectedFieldsResult.select,
+      relations: processedArgs.selectedFieldsResult.relations,
+      objectMetadataItemWithFieldMaps,
+      objectMetadataMaps,
+    });
+
+    const objectRecords = (await queryBuilder
+      .setFindOptions({
+        select: columnsToSelect,
+      })
+      .take(limit + 1)
+      .getMany()) as ObjectRecord[];
+
+    const pageInfo = getPageInfo(
+      objectRecords,
+      orderByWithIdCondition,
+      limit,
+      isForwardPagination,
+    );
+
+    if (objectRecords.length > limit) {
+      objectRecords.pop();
+    }
+
+    if (!isForwardPagination) {
+      objectRecords.reverse();
+    }
+
+    const parentObjectRecordsAggregatedValues =
+      await aggregateQueryBuilder.getRawOne();
+
+    if (processedArgs.selectedFieldsResult.relations) {
+      await this.processNestedRelationsHelper.processNestedRelations({
+        objectMetadataMaps,
+        parentObjectMetadataItem: objectMetadataItemWithFieldMaps,
+        parentObjectRecords: objectRecords,
+        parentObjectRecordsAggregatedValues,
+        //TODO : Refacto-common - Typing to fix when switching processNestedRelationsHelper to Common
+        relations: processedArgs.selectedFieldsResult.relations as Record<
+          string,
+          FindOptionsRelations<ObjectLiteral>
+        >,
+        aggregate: processedArgs.selectedFieldsResult.aggregate,
+        limit: QUERY_MAX_RECORDS,
+        authContext,
+        workspaceDataSource,
+        roleId,
+        shouldBypassPermissionChecks,
+        selectedFields: processedArgs.selectedFieldsResult.select,
+      });
+    }
+
+    const enrichedRecords = await this.enrichResultsWithGettersAndHooks({
+      results: objectRecords,
+      operationName: CommonQueryNames.findMany,
+      authContext,
+      objectMetadataItemWithFieldMaps,
+      objectMetadataMaps,
+    });
+
+    return {
+      records: enrichedRecords,
+      aggregatedValues: parentObjectRecordsAggregatedValues,
+      totalCount: parentObjectRecordsAggregatedValues?.totalCount,
+      pageInfo,
+    };
+  }
+
+  validate(args: FindManyQueryArgs) {
+    if (args.first && args.last) {
+      throw new CommonQueryRunnerException(
+        'Cannot provide both first and last',
+        CommonQueryRunnerExceptionCode.ARGS_CONFLICT,
+      );
+    }
+    if (args.before && args.after) {
+      throw new CommonQueryRunnerException(
+        'Cannot provide both before and after',
+        CommonQueryRunnerExceptionCode.ARGS_CONFLICT,
+      );
+    }
+    if (args.before && args.first) {
+      throw new CommonQueryRunnerException(
+        'Cannot provide both before and first',
+        CommonQueryRunnerExceptionCode.ARGS_CONFLICT,
+      );
+    }
+    if (args.after && args.last) {
+      throw new CommonQueryRunnerException(
+        'Cannot provide both after and last',
+        CommonQueryRunnerExceptionCode.ARGS_CONFLICT,
+      );
+    }
+    if (args.first !== undefined && args.first < 0) {
+      throw new CommonQueryRunnerException(
+        'First argument must be non-negative',
+        CommonQueryRunnerExceptionCode.INVALID_ARGS_FIRST,
+      );
+    }
+    if (args.last !== undefined && args.last < 0) {
+      throw new CommonQueryRunnerException(
+        'Last argument must be non-negative',
+        CommonQueryRunnerExceptionCode.INVALID_ARGS_LAST,
+      );
+    }
+  }
+
+  async processQueryArgs({
+    authContext,
+    objectMetadataItemWithFieldMaps,
+    args,
+  }: {
+    authContext: WorkspaceAuthContext;
+    objectMetadataItemWithFieldMaps: ObjectMetadataItemWithFieldMaps;
+    args: FindManyQueryArgs;
+  }): Promise<FindManyQueryArgs> {
+    const hookedArgs =
+      (await this.workspaceQueryHookService.executePreQueryHooks(
+        authContext,
+        objectMetadataItemWithFieldMaps.nameSingular,
+        CommonQueryNames.findMany,
+        args,
+        //TODO : Refacto-common - To fix when updating workspaceQueryHookService, removing gql typing dependency
+      )) as FindManyQueryArgs;
+
+    return {
+      ...hookedArgs,
+      filter: this.queryRunnerArgsFactory.overrideFilterByFieldMetadata(
+        hookedArgs.filter,
+        objectMetadataItemWithFieldMaps,
+      ),
+    };
+  }
+}
@@ -21,14 +21,13 @@ import {
 } from 'src/engine/api/common/types/common-query-args.type';
 import { isWorkspaceAuthContext } from 'src/engine/api/common/utils/is-workspace-auth-context.util';
 import { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
-import { ObjectRecordsToGraphqlConnectionHelper } from 'src/engine/api/graphql/graphql-query-runner/helpers/object-records-to-graphql-connection.helper';
 import { buildColumnsToSelect } from 'src/engine/api/graphql/graphql-query-runner/utils/build-columns-to-select';
 import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
 import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';

@Injectable()
-export class CommonFindOneQueryRunnerService extends CommonBaseQueryRunnerService<ObjectRecord> {
+export class CommonFindOneQueryRunnerService extends CommonBaseQueryRunnerService {
  async run({
    args,
    authContext: toValidateAuthContext,
@@ -137,23 +136,15 @@ export class CommonFindOneQueryRunnerService extends CommonBaseQueryRunnerServic
      });
    }

-    const typeORMObjectRecordsParser =
-      new ObjectRecordsToGraphqlConnectionHelper(objectMetadataMaps);
-
-    const results = typeORMObjectRecordsParser.processRecord({
-      objectRecord: objectRecords[0],
-      objectName: objectMetadataItemWithFieldMaps.nameSingular,
-      take: 1,
-      totalCount: 1,
-    }) as ObjectRecord;
-
-    return this.enrichResultsWithGettersAndHooks({
-      results,
+    const enrichedResults = await this.enrichResultsWithGettersAndHooks({
+      results: objectRecords,
      authContext,
      objectMetadataItemWithFieldMaps,
      objectMetadataMaps,
      operationName: CommonQueryNames.findOne,
    });
+
+    return enrichedResults[0];
  }

  async processQueryArgs({
@@ -1,3 +1,7 @@
+import { CommonFindManyQueryRunnerService } from 'src/engine/api/common/common-query-runners/common-find-many-query-runner.service';
 import { CommonFindOneQueryRunnerService } from 'src/engine/api/common/common-query-runners/common-find-one-query-runner.service';

-export const CommonQueryRunners = [CommonFindOneQueryRunnerService];
+export const CommonQueryRunners = [
+  CommonFindOneQueryRunnerService,
+  CommonFindManyQueryRunnerService,
+];
@@ -6,4 +6,7 @@ export enum CommonQueryRunnerExceptionCode {
  RECORD_NOT_FOUND = 'RECORD_NOT_FOUND',
  INVALID_QUERY_INPUT = 'INVALID_QUERY_INPUT',
  INVALID_AUTH_CONTEXT = 'INVALID_AUTH_CONTEXT',
+  ARGS_CONFLICT = 'ARGS_CONFLICT',
+  INVALID_ARGS_FIRST = 'INVALID_ARGS_FIRST',
+  INVALID_ARGS_LAST = 'INVALID_ARGS_LAST',
 }
@@ -16,6 +16,9 @@ export const commonQueryRunnerToGraphqlApiExceptionHandler = (
  switch (error.code) {
    case CommonQueryRunnerExceptionCode.RECORD_NOT_FOUND:
      throw new NotFoundError(error);
+    case CommonQueryRunnerExceptionCode.ARGS_CONFLICT:
+    case CommonQueryRunnerExceptionCode.INVALID_ARGS_FIRST:
+    case CommonQueryRunnerExceptionCode.INVALID_ARGS_LAST:
    case CommonQueryRunnerExceptionCode.INVALID_QUERY_INPUT:
      throw new UserInputError(error);
    case CommonQueryRunnerExceptionCode.INVALID_AUTH_CONTEXT:
@@ -15,6 +15,9 @@ export const commonQueryRunnerToRestApiExceptionHandler = (
  error: CommonQueryRunnerException,
 ): never => {
  switch (error.code) {
+    case CommonQueryRunnerExceptionCode.ARGS_CONFLICT:
+    case CommonQueryRunnerExceptionCode.INVALID_ARGS_FIRST:
+    case CommonQueryRunnerExceptionCode.INVALID_ARGS_LAST:
    case CommonQueryRunnerExceptionCode.INVALID_QUERY_INPUT:
      throw new BadRequestException(error.message);
    case CommonQueryRunnerExceptionCode.RECORD_NOT_FOUND: