Common - Update one/many, restore one/many, findDuplicates & mergeMany (#15279)

closes twentyhq/core-team-issues#1739

Author: etiennejouan

packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts

@@ -72,10 +72,11 @@ export abstract class CommonBaseQueryRunnerService<
   @Inject()
   protected readonly commonResultGettersService: CommonResultGettersService;
 
+  protected abstract readonly operationName: CommonQueryNames;
+
   public async execute(
     args: CommonInput<Args>,
     queryRunnerContext: CommonBaseQueryRunnerContext,
-    operationName: CommonQueryNames,
   ): Promise<Output> {
     const { authContext, objectMetadataItemWithFieldMaps, objectMetadataMaps } =
       queryRunnerContext;
@@ -104,7 +105,7 @@ export abstract class CommonBaseQueryRunnerService<
     const processedArgs = await this.processArgs(
       args,
       queryRunnerContext,
-      operationName,
+      this.operationName,
       commonQueryParser,
     );
 
@@ -121,7 +122,7 @@ export abstract class CommonBaseQueryRunnerService<
 
     return this.enrichResultsWithGettersAndHooks({
       results,
-      operationName,
+      operationName: this.operationName,
       authContext,
       objectMetadataItemWithFieldMaps,
       objectMetadataMaps,

packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts

@@ -21,6 +21,7 @@ import { CommonExtendedQueryRunnerContext } from 'src/engine/api/common/types/co
 import {
   CommonExtendedInput,
   CommonInput,
+  CommonQueryNames,
   CreateManyQueryArgs,
 } from 'src/engine/api/common/types/common-query-args.type';
 import { CommonSelectedFieldsResult } from 'src/engine/api/common/types/common-selected-fields-result.type';
@@ -34,13 +35,14 @@ import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/typ
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
 import { WorkspaceDataSource } from 'src/engine/twenty-orm/datasource/workspace.datasource';
 import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
+import { RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
 
 @Injectable()
 export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerService<
   CreateManyQueryArgs,
   ObjectRecord[]
 > {
+  protected readonly operationName = CommonQueryNames.CREATE_MANY;
   async run(
     args: CommonExtendedInput<CreateManyQueryArgs>,
     queryRunnerContext: CommonExtendedQueryRunnerContext,

packages/twenty-server/src/engine/api/common/common-query-runners/common-create-one-query-runner.service.ts

@@ -11,6 +11,7 @@ import { CommonExtendedQueryRunnerContext } from 'src/engine/api/common/types/co
 import {
   CommonExtendedInput,
   CommonInput,
+  CommonQueryNames,
   CreateManyQueryArgs,
   CreateOneQueryArgs,
 } from 'src/engine/api/common/types/common-query-args.type';
@@ -29,6 +30,8 @@ export class CommonCreateOneQueryRunnerService extends CommonBaseQueryRunnerServ
     super();
   }
 
+  protected readonly operationName = CommonQueryNames.CREATE_ONE;
+
   async run(
     args: CommonExtendedInput<CreateManyQueryArgs>,
     queryRunnerContext: CommonExtendedQueryRunnerContext,

packages/twenty-server/src/engine/api/common/common-query-runners/common-delete-many-query-runner.service.ts

@@ -17,6 +17,7 @@ import { CommonExtendedQueryRunnerContext } from 'src/engine/api/common/types/co
 import {
   CommonExtendedInput,
   CommonInput,
+  CommonQueryNames,
   DeleteManyQueryArgs,
 } from 'src/engine/api/common/types/common-query-args.type';
 import { buildColumnsToReturn } from 'src/engine/api/graphql/graphql-query-runner/utils/build-columns-to-return';
@@ -30,6 +31,8 @@ export class CommonDeleteManyQueryRunnerService extends CommonBaseQueryRunnerSer
   DeleteManyQueryArgs,
   ObjectRecord[]
 > {
+  protected readonly operationName = CommonQueryNames.DELETE_MANY;
+
   async run(
     args: CommonExtendedInput<DeleteManyQueryArgs>,
     queryRunnerContext: CommonExtendedQueryRunnerContext,

packages/twenty-server/src/engine/api/common/common-query-runners/common-delete-one-query-runner.service.ts

@@ -16,6 +16,7 @@ import { CommonExtendedQueryRunnerContext } from 'src/engine/api/common/types/co
 import {
   CommonExtendedInput,
   CommonInput,
+  CommonQueryNames,
   DeleteOneQueryArgs,
 } from 'src/engine/api/common/types/common-query-args.type';
 import { assertIsValidUuid } from 'src/engine/api/graphql/workspace-query-runner/utils/assert-is-valid-uuid.util';
@@ -33,6 +34,8 @@ export class CommonDeleteOneQueryRunnerService extends CommonBaseQueryRunnerServ
     super();
   }
 
+  protected readonly operationName = CommonQueryNames.DELETE_ONE;
+
   async run(
     args: CommonExtendedInput<DeleteOneQueryArgs>,
     queryRunnerContext: CommonExtendedQueryRunnerContext,

packages/twenty-server/src/engine/api/common/common-query-runners/common-destroy-many-query-runner.service.ts

@@ -17,6 +17,7 @@ import { CommonExtendedQueryRunnerContext } from 'src/engine/api/common/types/co
 import {
   CommonExtendedInput,
   CommonInput,
+  CommonQueryNames,
   DestroyManyQueryArgs,
 } from 'src/engine/api/common/types/common-query-args.type';
 import { buildColumnsToReturn } from 'src/engine/api/graphql/graphql-query-runner/utils/build-columns-to-return';
@@ -27,6 +28,8 @@ export class CommonDestroyManyQueryRunnerService extends CommonBaseQueryRunnerSe
   DestroyManyQueryArgs,
   ObjectRecord[]
 > {
+  protected readonly operationName = CommonQueryNames.DESTROY_MANY;
+
   async run(
     args: CommonExtendedInput<DestroyManyQueryArgs>,
     queryRunnerContext: CommonExtendedQueryRunnerContext,

packages/twenty-server/src/engine/api/common/common-query-runners/common-destroy-one-query-runner.service.ts

@@ -16,6 +16,7 @@ import { CommonExtendedQueryRunnerContext } from 'src/engine/api/common/types/co
 import {
   CommonExtendedInput,
   CommonInput,
+  CommonQueryNames,
   DestroyOneQueryArgs,
 } from 'src/engine/api/common/types/common-query-args.type';
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
@@ -31,6 +32,8 @@ export class CommonDestroyOneQueryRunnerService extends CommonBaseQueryRunnerSer
     super();
   }
 
+  protected readonly operationName = CommonQueryNames.DESTROY_ONE;
+
   async run(
     args: CommonExtendedInput<DestroyOneQueryArgs>,
     queryRunnerContext: CommonExtendedQueryRunnerContext,

packages/twenty-server/src/engine/api/common/common-query-runners/common-find-duplicates-query-runner.service.ts

@@ -0,0 +1,208 @@
+import { Injectable } from '@nestjs/common';
+
+import isEmpty from 'lodash.isempty';
+import { QUERY_MAX_RECORDS } from 'twenty-shared/constants';
+import { ObjectRecord, OrderByDirection } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { In } from 'typeorm';
+
+import { WorkspaceAuthContext } from 'src/engine/api/common/interfaces/workspace-auth-context.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 { CommonBaseQueryRunnerContext } from 'src/engine/api/common/types/common-base-query-runner-context.type';
+import { CommonExtendedQueryRunnerContext } from 'src/engine/api/common/types/common-extended-query-runner-context.type';
+import { CommonFindDuplicatesOutputItem } from 'src/engine/api/common/types/common-find-duplicates-output-item.type';
+import {
+  CommonExtendedInput,
+  CommonInput,
+  CommonQueryNames,
+  FindDuplicatesQueryArgs,
+} from 'src/engine/api/common/types/common-query-args.type';
+import { getPageInfo } from 'src/engine/api/common/utils/get-page-info.util';
+import { buildColumnsToSelect } from 'src/engine/api/graphql/graphql-query-runner/utils/build-columns-to-select';
+import { buildDuplicateConditions } from 'src/engine/api/utils/build-duplicate-conditions.utils';
+import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
+
+@Injectable()
+export class CommonFindDuplicatesQueryRunnerService extends CommonBaseQueryRunnerService<
+  FindDuplicatesQueryArgs,
+  CommonFindDuplicatesOutputItem[]
+> {
+  protected readonly operationName = CommonQueryNames.FIND_DUPLICATES;
+
+  async run(
+    args: CommonExtendedInput<FindDuplicatesQueryArgs>,
+    queryRunnerContext: CommonExtendedQueryRunnerContext,
+  ): Promise<CommonFindDuplicatesOutputItem[]> {
+    const {
+      repository,
+      objectMetadataItemWithFieldMaps,
+      objectMetadataMaps,
+      commonQueryParser,
+    } = queryRunnerContext;
+
+    const existingRecordsQueryBuilder = repository.createQueryBuilder(
+      objectMetadataItemWithFieldMaps.nameSingular,
+    );
+
+    let objectRecords: Partial<ObjectRecord>[] = [];
+
+    const columnsToSelect = buildColumnsToSelect({
+      select: args.selectedFieldsResult.select,
+      relations: args.selectedFieldsResult.relations,
+      objectMetadataItemWithFieldMaps,
+      objectMetadataMaps,
+    });
+
+    if (isDefined(args.ids)) {
+      objectRecords = (await existingRecordsQueryBuilder
+        .where({ id: In(args.ids) })
+        .setFindOptions({
+          select: columnsToSelect,
+        })
+        .getMany()) as ObjectRecord[];
+    } else if (args.data && !isEmpty(args.data)) {
+      objectRecords = args.data;
+    }
+
+    const findDuplicatesOutput: CommonFindDuplicatesOutputItem[] =
+      await Promise.all(
+        objectRecords.map(async (record) => {
+          const duplicateConditions = buildDuplicateConditions(
+            objectMetadataItemWithFieldMaps,
+            [record],
+            record.id,
+          );
+
+          if (isEmpty(duplicateConditions)) {
+            return {
+              records: [],
+              totalCount: 0,
+              hasNextPage: false,
+              hasPreviousPage: false,
+              startCursor: null,
+              endCursor: null,
+            };
+          }
+
+          const duplicateRecordsQueryBuilder = repository.createQueryBuilder(
+            objectMetadataItemWithFieldMaps.nameSingular,
+          );
+
+          commonQueryParser.applyFilterToBuilder(
+            duplicateRecordsQueryBuilder,
+            objectMetadataItemWithFieldMaps.nameSingular,
+            duplicateConditions,
+          );
+
+          const duplicates = (await duplicateRecordsQueryBuilder
+            .setFindOptions({
+              select: columnsToSelect,
+            })
+            .take(QUERY_MAX_RECORDS)
+            .getMany()) as ObjectRecord[];
+
+          const aggregateQueryBuilder = duplicateRecordsQueryBuilder.clone();
+          const totalCount = await aggregateQueryBuilder.getCount();
+
+          const { startCursor, endCursor } = getPageInfo(
+            duplicates,
+            [{ id: OrderByDirection.AscNullsFirst }],
+            QUERY_MAX_RECORDS,
+            true,
+          );
+
+          return {
+            records: duplicates,
+            totalCount,
+            hasNextPage: false,
+            hasPreviousPage: false,
+            startCursor,
+            endCursor,
+          };
+        }),
+      );
+
+    return findDuplicatesOutput;
+  }
+
+  async computeArgs(
+    args: CommonInput<FindDuplicatesQueryArgs>,
+    queryRunnerContext: CommonBaseQueryRunnerContext,
+  ): Promise<CommonInput<FindDuplicatesQueryArgs>> {
+    const { authContext, objectMetadataItemWithFieldMaps } = queryRunnerContext;
+
+    return {
+      ...args,
+      ids: await Promise.all(
+        args.ids?.map((id) =>
+          this.queryRunnerArgsFactory.overrideValueByFieldMetadata(
+            'id',
+            id,
+            objectMetadataItemWithFieldMaps.fieldsById,
+            objectMetadataItemWithFieldMaps,
+          ),
+        ) ?? [],
+      ),
+      data: await this.queryRunnerArgsFactory.overrideDataByFieldMetadata({
+        partialRecordInputs: args.data,
+        authContext,
+        objectMetadataItemWithFieldMaps,
+        shouldBackfillPositionIfUndefined: false,
+      }),
+    };
+  }
+
+  async processQueryResult(
+    queryResult: CommonFindDuplicatesOutputItem[],
+    objectMetadataItemId: string,
+    objectMetadataMaps: ObjectMetadataMaps,
+    authContext: WorkspaceAuthContext,
+  ): Promise<CommonFindDuplicatesOutputItem[]> {
+    const processedResults = await Promise.all(
+      queryResult.map(async (result) => {
+        return {
+          ...result,
+          records: await this.commonResultGettersService.processRecordArray(
+            result.records,
+            objectMetadataItemId,
+            objectMetadataMaps,
+            authContext.workspace.id,
+          ),
+        };
+      }),
+    );
+
+    return processedResults;
+  }
+
+  async validate(
+    args: CommonInput<FindDuplicatesQueryArgs>,
+    _queryRunnerContext: CommonBaseQueryRunnerContext,
+  ): Promise<void> {
+    if (!args.data && !args.ids) {
+      throw new CommonQueryRunnerException(
+        'You have to provide either "data" or "ids" argument',
+        CommonQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
+      );
+    }
+
+    if (args.data && args.ids) {
+      throw new CommonQueryRunnerException(
+        'You cannot provide both "data" and "ids" arguments',
+        CommonQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
+      );
+    }
+
+    if (!args.ids && isEmpty(args.data)) {
+      throw new CommonQueryRunnerException(
+        'The "data" condition can not be empty when "ids" input not provided',
+        CommonQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
+      );
+    }
+  }
+}

packages/twenty-server/src/engine/api/common/common-query-runners/common-find-many-query-runner.service.ts

@@ -22,6 +22,7 @@ import { CommonFindManyOutput } from 'src/engine/api/common/types/common-find-ma
 import {
   CommonExtendedInput,
   CommonInput,
+  CommonQueryNames,
   FindManyQueryArgs,
 } from 'src/engine/api/common/types/common-query-args.type';
 import { getPageInfo } from 'src/engine/api/common/utils/get-page-info.util';
@@ -36,6 +37,8 @@ export class CommonFindManyQueryRunnerService extends CommonBaseQueryRunnerServi
   FindManyQueryArgs,
   CommonFindManyOutput
 > {
+  protected readonly operationName = CommonQueryNames.FIND_MANY;
+
   async run(
     args: CommonExtendedInput<FindManyQueryArgs>,
     queryRunnerContext: CommonExtendedQueryRunnerContext,

packages/twenty-server/src/engine/api/common/common-query-runners/common-find-one-query-runner.service.ts

@@ -18,6 +18,7 @@ import { CommonExtendedQueryRunnerContext } from 'src/engine/api/common/types/co
 import {
   CommonExtendedInput,
   CommonInput,
+  CommonQueryNames,
   FindOneQueryArgs,
 } from 'src/engine/api/common/types/common-query-args.type';
 import { buildColumnsToSelect } from 'src/engine/api/graphql/graphql-query-runner/utils/build-columns-to-select';
@@ -28,6 +29,8 @@ export class CommonFindOneQueryRunnerService extends CommonBaseQueryRunnerServic
   FindOneQueryArgs,
   ObjectRecord
 > {
+  protected readonly operationName = CommonQueryNames.FIND_ONE;
+
   async run(
     args: CommonExtendedInput<FindOneQueryArgs>,
     queryRunnerContext: CommonExtendedQueryRunnerContext,