Begin performance improvements

FelixMalfait · FelixMalfait · commit 5f155bb48d33 · 2024-06-24T17:30:07.000+02:00
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-query-builder/factories/find-duplicates-query.factory.ts b/packages/twenty-server/src/engine/api/graphql/workspace-query-builder/factories/find-duplicates-query.factory.ts
@@ -3,7 +3,7 @@ import { Injectable, Logger } from '@nestjs/common';
 import isEmpty from 'lodash.isempty';
 
 import { WorkspaceQueryBuilderOptions } from 'src/engine/api/graphql/workspace-query-builder/interfaces/workspace-query-builder-options.interface';
-import { RecordFilter } from 'src/engine/api/graphql/workspace-query-builder/interfaces/record.interface';
+import { Record } from 'src/engine/api/graphql/workspace-query-builder/interfaces/record.interface';
 import { FindDuplicatesResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
 
 import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target-table.util';
@@ -23,57 +23,71 @@ export class FindDuplicatesQueryFactory {
     private readonly duplicateService: DuplicateService,
   ) {}
 
-  async create<Filter extends RecordFilter = RecordFilter>(
-    args: FindDuplicatesResolverArgs<Filter>,
+  async create(
+    args: FindDuplicatesResolverArgs,
     options: WorkspaceQueryBuilderOptions,
-    currentRecord?: Record<string, unknown>,
+    currentRecord?: Record,
   ) {
     const fieldsString = await this.fieldsStringFactory.create(
       options.info,
       options.fieldMetadataCollection,
       options.objectMetadataCollection,
     );
 
-    const argsData = this.getFindDuplicateBy<Filter>(
-      args,
-      options,
-      currentRecord,
-    );
+    if (currentRecord) {
+      return `query {
+        ${this.buildQuery(fieldsString, options, undefined, currentRecord)}
+      }`;
+    }
 
-    const duplicateCondition =
-      this.duplicateService.buildDuplicateConditionForGraphQL(
-        options.objectMetadataItem,
-        argsData,
-        args.id,
+    const query = args.data?.reduce((acc, dataItem, index) => {
+      const argsData = this.argsAliasFactory.create(
+        dataItem ?? {},
+        options.fieldMetadataCollection,
       );
 
-    const filters = stringifyWithoutKeyQuote(duplicateCondition);
+      return (
+        acc +
+        this.buildQuery(
+          fieldsString,
+          options,
+          argsData as Record,
+          undefined,
+          index,
+        )
+      );
+    }, '');
 
-    return `
-      query {
-        ${computeObjectTargetTable(options.objectMetadataItem)}Collection${
-          isEmpty(duplicateCondition?.or)
-            ? '(first: 0)'
-            : `(filter: ${filters})`
-        } {
-          ${fieldsString}
-        }
-      }
-    `;
+    return `query {
+      ${query}
+    }`;
   }
 
-  getFindDuplicateBy<Filter extends RecordFilter = RecordFilter>(
-    args: FindDuplicatesResolverArgs<Filter>,
+  buildQuery(
+    fieldsString: string,
     options: WorkspaceQueryBuilderOptions,
-    currentRecord?: Record<string, unknown>,
+    data?: Record,
+    currentRecord?: Record,
+    index?: number,
   ) {
-    if (currentRecord) {
-      return currentRecord;
-    }
+    const duplicateCondition =
+      this.duplicateService.buildDuplicateConditionForGraphQL(
+        options.objectMetadataItem,
+        data ?? currentRecord,
+        currentRecord?.id,
+      );
 
-    return this.argsAliasFactory.create(
-      args.data ?? {},
-      options.fieldMetadataCollection,
-    );
+    const filters = stringifyWithoutKeyQuote(duplicateCondition);
+
+    return `${computeObjectTargetTable(
+      options.objectMetadataItem,
+    )}Collection${index}: ${computeObjectTargetTable(
+      options.objectMetadataItem,
+    )}Collection${
+      isEmpty(duplicateCondition?.or) ? '(first: 0)' : `(filter: ${filters})`
+    } {
+        ${fieldsString}
+    }
+  `;
   }
 }
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-query-builder/workspace-query-builder.factory.ts b/packages/twenty-server/src/engine/api/graphql/workspace-query-builder/workspace-query-builder.factory.ts
@@ -64,12 +64,12 @@ export class WorkspaceQueryBuilderFactory {
     return this.findOneQueryFactory.create<Filter>(args, options);
   }
 
-  findDuplicates<Filter extends RecordFilter = RecordFilter>(
-    args: FindDuplicatesResolverArgs<Filter>,
+  findDuplicates(
+    args: FindDuplicatesResolverArgs,
     options: WorkspaceQueryBuilderOptions,
-    existingRecord?: Record<string, unknown>,
+    existingRecord?: IRecord,
   ): Promise<string> {
-    return this.findDuplicatesQueryFactory.create<Filter>(
+    return this.findDuplicatesQueryFactory.create(
       args,
       options,
       existingRecord,
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/factories/query-runner-args.factory.ts b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/factories/query-runner-args.factory.ts
@@ -47,12 +47,12 @@ export class QueryRunnerArgsFactory {
         return {
           ...args,
           data: await Promise.all(
-            (args as CreateManyResolverArgs).data.map((arg, index) =>
+            (args as CreateManyResolverArgs).data?.map((arg, index) =>
               this.overrideDataByFieldMetadata(arg, options, fieldMetadataMap, {
                 argIndex: index,
                 shouldBackfillPosition,
               }),
-            ),
+            ) ?? [],
           ),
         } satisfies CreateManyResolverArgs;
       case ResolverArgsType.FindOne:
@@ -80,11 +80,13 @@ export class QueryRunnerArgsFactory {
             (args as FindDuplicatesResolverArgs).id,
             fieldMetadataMap,
           ),
-          data: await this.overrideDataByFieldMetadata(
-            (args as FindDuplicatesResolverArgs).data,
-            options,
-            fieldMetadataMap,
-            { shouldBackfillPosition: false },
+          data: await Promise.all(
+            (args as FindDuplicatesResolverArgs).data?.map((arg, index) =>
+              this.overrideDataByFieldMetadata(arg, options, fieldMetadataMap, {
+                argIndex: index,
+                shouldBackfillPosition,
+              }),
+            ) ?? [],
           ),
         };
       default:
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-runner.service.ts b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-runner.service.ts
@@ -192,24 +192,24 @@ export class WorkspaceQueryRunnerService {
       ResolverArgsType.FindDuplicates,
     )) as FindDuplicatesResolverArgs<TRecord>;
 
-    let existingRecord: Record<string, unknown> | undefined;
+    let existingRecord: Record<string, any> | null = null;
 
     if (computedArgs.id) {
-      existingRecord = await this.duplicateService.findExistingRecord(
-        computedArgs.id,
+      existingRecord = await this.duplicateService.findExistingRecords(
+        [computedArgs.id],
         objectMetadataItem,
         workspaceId,
       );
 
-      if (!existingRecord) {
+      if (existingRecord && existingRecord.length != 1) {
         throw new NotFoundError(`Object with id ${args.id} not found`);
       }
     }
 
     const query = await this.workspaceQueryBuilderFactory.findDuplicates(
       computedArgs,
       options,
-      existingRecord,
+      existingRecord ? existingRecord[0] : null,
     );
 
     await this.workspacePreQueryHookService.executePreHooks(
@@ -226,6 +226,7 @@ export class WorkspaceQueryRunnerService {
       result,
       objectMetadataItem,
       '',
+      true,
     );
   }
 
@@ -652,11 +653,28 @@ export class WorkspaceQueryRunnerService {
     graphqlResult: PGGraphQLResult | undefined,
     objectMetadataItem: ObjectMetadataInterface,
     command: string,
+    isMultiQuery = false,
   ): Promise<Result> {
     const entityKey = `${command}${computeObjectTargetTable(
       objectMetadataItem,
     )}Collection`;
-    const result = graphqlResult?.[0]?.resolve?.data?.[entityKey];
+    const result = !isMultiQuery
+      ? graphqlResult?.[0]?.resolve?.data?.[entityKey]
+      : {
+          edges: Object.keys(graphqlResult?.[0]?.resolve?.data).reduce(
+            (acc: IRecord[], dataItem, index) => {
+              acc.push(
+                graphqlResult?.[0]?.resolve?.data[`${entityKey}${index}`].edges,
+              );
+
+              return acc;
+            },
+            [],
+          )[0],
+        };
+
+    console.log('result', result);
+
     const errors = graphqlResult?.[0]?.resolve?.errors;
 
     if (
@@ -687,6 +705,8 @@ export class WorkspaceQueryRunnerService {
       objectMetadataItem,
     );
 
+    console.log(resultWithGetters);
+
     return parseResult(resultWithGetters);
   }
 
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface.ts b/packages/twenty-server/src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface.ts
@@ -41,7 +41,7 @@ export interface FindOneResolverArgs<Filter = any> {
 
 export interface FindDuplicatesResolverArgs<Data extends Record = Record> {
   id?: string;
-  data?: Data;
+  data?: Data[];
 }
 
 export interface CreateOneResolverArgs<Data extends Record = Record> {
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/utils/get-resolver-args.util.ts b/packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/utils/get-resolver-args.util.ts
@@ -94,6 +94,7 @@ export const getResolverArgs = (
         data: {
           kind: InputTypeDefinitionKind.Create,
           isNullable: true,
+          isArray: true,
         },
       };
     case 'deleteOne':
diff --git a/packages/twenty-server/src/engine/core-modules/duplicate/duplicate.service.ts b/packages/twenty-server/src/engine/core-modules/duplicate/duplicate.service.ts
@@ -13,8 +13,8 @@ export class DuplicateService {
     private readonly workspaceDataSourceService: WorkspaceDataSourceService,
   ) {}
 
-  async findExistingRecord(
-    recordId: string | number,
+  async findExistingRecords(
+    recordIds: (string | number)[],
     objectMetadata: ObjectMetadataInterface,
     workspaceId: string,
   ) {
@@ -30,13 +30,15 @@ export class DuplicateService {
                 objectMetadata,
               )}" p
           WHERE
-              p."id" = $1
+              p."id" IN (${recordIds
+                .map((_, index) => `$${index + 1}`)
+                .join(', ')})
           `,
-      [recordId],
+      recordIds,
       workspaceId,
     );
 
-    return results.length > 0 ? results[0] : null;
+    return results as Record<string, any>[] | null;
   }
 
   async findDuplicate(

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ export interface FindOneResolverArgs<Filter = any> {`
`41`	`41`
`42`	`42`	`export interface FindDuplicatesResolverArgs<Data extends Record = Record> {`
`43`	`43`	`id?: string;`
`44`		`- data?: Data;`
	`44`	`+ data?: Data[];`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`export interface CreateOneResolverArgs<Data extends Record = Record> {`