add restoration logic for contacts and companies - to do test

etiennejouan · etiennejouan · commit a05452178646 · 2025-09-23T11:00:29.000+02:00
diff --git a/packages/twenty-server/src/modules/contact-creation-manager/services/__tests__/create-company.service.spec.ts b/packages/twenty-server/src/modules/contact-creation-manager/services/__tests__/create-company.service.spec.ts
@@ -138,7 +138,7 @@ describe('CreateCompanyService', () => {
     });
 
     it('should successfully create a company', async () => {
-      await service.createCompanies([companyToCreate1], workspaceId);
+      await service.createOrRestoreCompanies([companyToCreate1], workspaceId);
 
       expect(mockCompanyRepository.find).toHaveBeenCalled();
       expect(mockCompanyRepository.save).toHaveBeenCalledWith([
@@ -147,7 +147,7 @@ describe('CreateCompanyService', () => {
     });
 
     it('should successfully two companies', async () => {
-      await service.createCompanies(
+      await service.createOrRestoreCompanies(
         [companyToCreate1, companyToCreate2],
         workspaceId,
       );
@@ -160,7 +160,7 @@ describe('CreateCompanyService', () => {
     });
 
     it('should create only one of example.com & example.com/ ', async () => {
-      await service.createCompanies(
+      await service.createOrRestoreCompanies(
         [companyToCreate1, companyToCreate1withSlash],
         workspaceId,
       );
@@ -190,7 +190,10 @@ describe('CreateCompanyService', () => {
     });
 
     it('should not create a company if it already exists', async () => {
-      await service.createCompanies([companyToCreateExisting], workspaceId);
+      await service.createOrRestoreCompanies(
+        [companyToCreateExisting],
+        workspaceId,
+      );
 
       expect(mockCompanyRepository.find).toHaveBeenCalled();
       expect(mockCompanyRepository.save).not.toHaveBeenCalled();
diff --git a/packages/twenty-server/src/modules/contact-creation-manager/services/create-company-and-contact.service.ts b/packages/twenty-server/src/modules/contact-creation-manager/services/create-company-and-contact.service.ts
@@ -3,6 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { isNonEmptyString } from '@sniptt/guards';
 import chunk from 'lodash.chunk';
 import compact from 'lodash.compact';
+import { isDefined } from 'twenty-shared/utils';
 import { type DeepPartial } from 'typeorm';
 
 import { ExceptionHandlerService } from 'src/engine/core-modules/exception-handler/exception-handler.service';
@@ -141,10 +142,11 @@ export class CreateCompanyAndContactService {
       }),
     );
 
-    const companiesObject = await this.createCompaniesService.createCompanies(
-      workDomainNamesToCreateFormatted,
-      workspaceId,
-    );
+    const companiesObject =
+      await this.createCompaniesService.createOrRestoreCompanies(
+        workDomainNamesToCreateFormatted,
+        workspaceId,
+      );
 
     const formattedContactsToCreate =
       filteredContactsToCreateWithCompanyDomainNames.map((contact) => ({
@@ -160,10 +162,89 @@ export class CreateCompanyAndContactService {
         },
       }));
 
-    return this.createContactService.createPeople(
+    const restoredContacts =
+      await this.restorePeopleAndRestoreOrCreateCompanies(
+        alreadyCreatedContacts,
+        uniqueContacts,
+        workspaceId,
+        source,
+        connectedAccount,
+      );
+
+    const createdContacts = await this.createContactService.createPeople(
       formattedContactsToCreate,
       workspaceId,
     );
+
+    return [...restoredContacts, ...createdContacts];
+  }
+
+  async restorePeopleAndRestoreOrCreateCompanies(
+    alreadyCreatedContacts: PersonWorkspaceEntity[],
+    uniqueContacts: Contact[],
+    workspaceId: string,
+    source: FieldActorSource,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ) {
+    const filteredContactsToRestore = uniqueContacts
+      .map((contact) => {
+        const softDeletedContact = alreadyCreatedContacts.find(
+          (person) =>
+            isDefined(person.deletedAt) &&
+            (person.emails.primaryEmail === contact.handle.toLowerCase() ||
+              (Array.isArray(person.emails?.additionalEmails) &&
+                person.emails.additionalEmails.includes(
+                  contact.handle.toLowerCase(),
+                ))),
+        );
+
+        return isDefined(softDeletedContact)
+          ? {
+              id: softDeletedContact.id,
+              companyDomainName: isWorkEmail(contact.handle)
+                ? getDomainNameFromHandle(contact.handle)
+                : undefined,
+            }
+          : undefined;
+      })
+      .filter(isDefined);
+
+    const workDomainNamesToCreate = filteredContactsToRestore
+      .filter(
+        (participant) =>
+          isDefined(participant.companyDomainName) &&
+          isWorkDomain(participant.companyDomainName),
+      )
+      .map((participant) => ({
+        domainName: participant.companyDomainName,
+        createdBySource: source,
+        createdByWorkspaceMember: connectedAccount.accountOwner,
+        createdByContext: {
+          provider: connectedAccount.provider,
+        },
+      }));
+
+    const companiesObject =
+      await this.createCompaniesService.createOrRestoreCompanies(
+        workDomainNamesToCreate,
+        workspaceId,
+      );
+
+    const formattedContactsToRestore = filteredContactsToRestore.map(
+      (contact) => {
+        return {
+          id: contact.id,
+          companyId: isNonEmptyString(contact.companyDomainName)
+            ? companiesObject[contact.companyDomainName]
+            : undefined,
+        };
+      },
+    );
+
+    return this.createContactService.restorePeople(
+      formattedContactsToRestore,
+      workspaceId,
+    );
   }
 
   async createCompaniesAndContactsAndUpdateParticipants(
diff --git a/packages/twenty-server/src/modules/contact-creation-manager/services/create-company.service.ts b/packages/twenty-server/src/modules/contact-creation-manager/services/create-company.service.ts
@@ -4,7 +4,10 @@ import axios, { type AxiosInstance } from 'axios';
 import uniqBy from 'lodash.uniqby';
 import { TWENTY_COMPANIES_BASE_URL } from 'twenty-shared/constants';
 import { type ConnectedAccountProvider } from 'twenty-shared/types';
-import { lowercaseUrlOriginAndRemoveTrailingSlash } from 'twenty-shared/utils';
+import {
+  isDefined,
+  lowercaseUrlOriginAndRemoveTrailingSlash,
+} from 'twenty-shared/utils';
 import { type DeepPartial, ILike } from 'typeorm';
 
 import { type FieldActorSource } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
@@ -35,7 +38,7 @@ export class CreateCompanyService {
     });
   }
 
-  async createCompanies(
+  async createOrRestoreCompanies(
     companies: CompanyToCreate[],
     workspaceId: string,
   ): Promise<{
@@ -73,6 +76,7 @@ export class CreateCompanyService {
     // Find existing companies
     const existingCompanies = await companyRepository.find({
       where: conditions,
+      withDeleted: true,
     });
     const existingCompanyIdsMap = this.createCompanyMap(existingCompanies);
 
@@ -87,7 +91,12 @@ export class CreateCompanyService {
         ),
     );
 
-    if (newCompaniesToCreate.length === 0) {
+    const companiesToRestore = this.filterCompaniesToRestore(
+      uniqueCompanies,
+      existingCompanies,
+    );
+
+    if (newCompaniesToCreate.length === 0 && companiesToRestore.length === 0) {
       return existingCompanyIdsMap;
     }
 
@@ -103,14 +112,66 @@ export class CreateCompanyService {
     // Create new companies
     const createdCompanies = await companyRepository.save(newCompaniesData);
 
-    const createdCompanyIdsMap = this.createCompanyMap(createdCompanies);
+    const restoredCompanies = await companyRepository.updateMany(
+      companiesToRestore.map((company) => {
+        return {
+          criteria: company.id,
+          partialEntity: {
+            deletedAt: null,
+          },
+        };
+      }),
+      undefined,
+      ['domainNamePrimaryLinkUrl', 'id'],
+    );
+
+    //TODO : Fix updateMany method to return formatted records
+    const formattedRestoredCompanies = restoredCompanies.raw.map(
+      (row: { id: string; domainNamePrimaryLinkUrl: string }) => {
+        return {
+          id: row.id,
+          domainName: {
+            primaryLinkUrl: row.domainNamePrimaryLinkUrl,
+          },
+        };
+      },
+    );
 
     return {
       ...existingCompanyIdsMap,
-      ...createdCompanyIdsMap,
+      ...(createdCompanies.length > 0
+        ? this.createCompanyMap(createdCompanies)
+        : {}),
+      ...(formattedRestoredCompanies.length > 0
+        ? this.createCompanyMap(formattedRestoredCompanies)
+        : {}),
     };
   }
 
+  private filterCompaniesToRestore(
+    uniqueCompanies: CompanyToCreate[],
+    existingCompanies: CompanyWorkspaceEntity[],
+  ) {
+    return uniqueCompanies
+      .map((company) => {
+        const existingCompany = existingCompanies.find(
+          (existingCompany) =>
+            existingCompany.domainName &&
+            extractDomainFromLink(existingCompany.domainName.primaryLinkUrl) ===
+              company.domainName,
+        );
+
+        return isDefined(existingCompany)
+          ? {
+              domainName: company.domainName,
+              id: existingCompany.id,
+              deletedAt: null,
+            }
+          : undefined;
+      })
+      .filter(isDefined);
+  }
+
   private async prepareCompanyData(
     company: CompanyToCreate,
     position: number,
@@ -142,7 +203,9 @@ export class CreateCompanyService {
     };
   }
 
-  private createCompanyMap(companies: DeepPartial<CompanyWorkspaceEntity>[]) {
+  private createCompanyMap(
+    companies: Pick<CompanyWorkspaceEntity, 'id' | 'domainName'>[],
+  ) {
     return companies.reduce(
       (acc, company) => {
         if (!company.domainName?.primaryLinkUrl || !company.id) {
diff --git a/packages/twenty-server/src/modules/contact-creation-manager/services/create-contact.service.ts b/packages/twenty-server/src/modules/contact-creation-manager/services/create-contact.service.ts
@@ -23,6 +23,11 @@ type ContactToCreate = {
   };
 };
 
+type ContactToRestore = {
+  id: string;
+  companyId?: string;
+};
+
 @Injectable()
 export class CreateContactService {
   constructor(
@@ -97,6 +102,36 @@ export class CreateContactService {
     return personRepository.save(formattedContacts, undefined);
   }
 
+  public async restorePeople(
+    contactsToRestore: ContactToRestore[],
+    workspaceId: string,
+  ): Promise<DeepPartial<PersonWorkspaceEntity>[]> {
+    if (contactsToRestore.length === 0) return [];
+
+    const personRepository =
+      await this.twentyORMGlobalManager.getRepositoryForWorkspace(
+        workspaceId,
+        PersonWorkspaceEntity,
+        {
+          shouldBypassPermissionChecks: true,
+        },
+      );
+
+    const restoredContacts = await personRepository.updateMany(
+      contactsToRestore.map((contact) => ({
+        criteria: contact.id,
+        partialEntity: {
+          companyId: contact.companyId,
+          deletedAt: null,
+        },
+      })),
+      undefined,
+      ['companyId', 'id'],
+    );
+
+    return restoredContacts.raw;
+  }
+
   private async getLastPersonPosition(
     personRepository: WorkspaceRepository<PersonWorkspaceEntity>,
   ): Promise<number> {
diff --git a/packages/twenty-server/src/modules/match-participant/utils/add-person-email-filters-to-query-builder.ts b/packages/twenty-server/src/modules/match-participant/utils/add-person-email-filters-to-query-builder.ts
@@ -30,10 +30,12 @@ export function addPersonEmailFiltersToQueryBuilder({
       'person.id',
       'person.emailsPrimaryEmail',
       'person.emailsAdditionalEmails',
+      'person.deletedAt',
     ])
     .where('LOWER(person.emailsPrimaryEmail) IN (:...emails)', {
       emails: normalizedEmails,
-    });
+    })
+    .withDeleted();
 
   if (excludePersonIds.length > 0) {
     queryBuilder = queryBuilder.andWhere(
