Upgrade relation picker (#8795)

- Rename all parts using the name "relation" to "record" when component
is only selecting record
- Remove the use of scope states in folder
- Rename entities to records

This PR prepares the use of the record picker in workflows

packages/twenty-front/src/modules/search/hooks/__mocks__/useFilteredSearchRecordQuery.ts

@@ -144,7 +144,7 @@ export const query = gql`
 `;
 
 export const variables = {
-  entitiesToSelect: {
+  recordsToSelect: {
     limit: 10,
     filter: {
       and: [
@@ -154,7 +154,7 @@ export const variables = {
     },
     orderBy: [{ name: 'AscNullsLast' }],
   },
-  filteredSelectedEntities: {
+  filteredSelectedRecords: {
     limit: 60,
     filter: {
       and: [

packages/twenty-front/src/modules/search/hooks/__tests__/useFilteredSearchRecordQuery.test.tsx

@@ -5,7 +5,7 @@ import { RecoilRoot, useSetRecoilState } from 'recoil';
 
 import { currentWorkspaceMemberState } from '@/auth/states/currentWorkspaceMemberState';
 import { objectMetadataItemsState } from '@/object-metadata/states/objectMetadataItemsState';
-import { EntitiesForMultipleEntitySelect } from '@/object-record/relation-picker/types/EntitiesForMultipleEntitySelect';
+import { RecordsForMultipleRecordSelect } from '@/object-record/relation-picker/types/RecordsForMultipleRecordSelect';
 import { SnackBarProviderScope } from '@/ui/feedback/snack-bar-manager/scopes/SnackBarProviderScope';
 
 import { generatedMockObjectMetadataItems } from '~/testing/mock-data/generatedMockObjectMetadataItems';
@@ -13,14 +13,14 @@ import {
   query,
   responseData,
   variables,
-} from '../__mocks__/useFilteredSearchEntityQuery';
-import { useFilteredSearchEntityQuery } from '../useFilteredSearchEntityQuery';
+} from '../__mocks__/useFilteredSearchRecordQuery';
+import { useFilteredSearchRecordQuery } from '../useFilteredSearchRecordQuery';
 
 const mocks = [
   {
     request: {
       query,
-      variables: variables.entitiesToSelect,
+      variables: variables.recordsToSelect,
     },
     result: jest.fn(() => ({
       data: {
@@ -31,7 +31,7 @@ const mocks = [
   {
     request: {
       query,
-      variables: variables.filteredSelectedEntities,
+      variables: variables.filteredSelectedRecords,
     },
     result: jest.fn(() => ({
       data: {
@@ -62,7 +62,7 @@ const Wrapper = ({ children }: { children: ReactNode }) => (
   </RecoilRoot>
 );
 
-describe('useFilteredSearchEntityQuery', () => {
+describe('useFilteredSearchRecordQuery', () => {
   it('returns the correct result when everything is provided', async () => {
     const { result } = renderHook(
       () => {
@@ -79,10 +79,10 @@ describe('useFilteredSearchEntityQuery', () => {
 
         setMetadataItems(generatedMockObjectMetadataItems);
 
-        return useFilteredSearchEntityQuery({
+        return useFilteredSearchRecordQuery({
           selectedIds: ['1'],
           limit: 10,
-          excludeRecordIds: ['2'],
+          excludedRecordIds: ['2'],
           objectNameSingular: 'person',
           searchFilter: 'Entity',
         });
@@ -90,10 +90,10 @@ describe('useFilteredSearchEntityQuery', () => {
       { wrapper: Wrapper },
     );
 
-    const expectedResult: EntitiesForMultipleEntitySelect<any> = {
-      selectedEntities: [],
-      filteredSelectedEntities: [],
-      entitiesToSelect: [],
+    const expectedResult: RecordsForMultipleRecordSelect<any> = {
+      selectedRecords: [],
+      filteredSelectedRecords: [],
+      recordsToSelect: [],
       loading: true,
     };
 

packages/twenty-front/src/modules/search/hooks/useFilteredSearchRecordQuery.ts

@@ -1,27 +1,27 @@
 import { useMapToObjectRecordIdentifier } from '@/object-metadata/hooks/useMapToObjectRecordIdentifier';
 import { DEFAULT_SEARCH_REQUEST_LIMIT } from '@/object-record/constants/DefaultSearchRequestLimit';
 import { useSearchRecords } from '@/object-record/hooks/useSearchRecords';
-import { EntitiesForMultipleEntitySelect } from '@/object-record/relation-picker/types/EntitiesForMultipleEntitySelect';
-import { EntityForSelect } from '@/object-record/relation-picker/types/EntityForSelect';
+import { RecordForSelect } from '@/object-record/relation-picker/types/RecordForSelect';
+import { RecordsForMultipleRecordSelect } from '@/object-record/relation-picker/types/RecordsForMultipleRecordSelect';
 import { ObjectRecord } from '@/object-record/types/ObjectRecord';
 import { isDefined } from '~/utils/isDefined';
 
-// TODO: use this for all search queries, because we need selectedEntities and entitiesToSelect each time we want to search
+// TODO: use this for all search queries, because we need selectedRecords and recordsToSelect each time we want to search
 // Filtered entities to select are
 
-export const useFilteredSearchEntityQuery = ({
+export const useFilteredSearchRecordQuery = ({
   selectedIds,
   limit,
-  excludeRecordIds = [],
+  excludedRecordIds = [],
   objectNameSingular,
   searchFilter,
 }: {
   selectedIds: string[];
   limit?: number;
-  excludeRecordIds?: string[];
+  excludedRecordIds?: string[];
   objectNameSingular: string;
   searchFilter?: string;
-}): EntitiesForMultipleEntitySelect<EntityForSelect> => {
+}): RecordsForMultipleRecordSelect<RecordForSelect> => {
   const { mapToObjectRecordIdentifier } = useMapToObjectRecordIdentifier({
     objectNameSingular,
   });
@@ -50,7 +50,7 @@ export const useFilteredSearchEntityQuery = ({
     searchInput: searchFilter,
   });
 
-  const notFilterIds = [...selectedIds, ...excludeRecordIds];
+  const notFilterIds = [...selectedIds, ...excludedRecordIds];
   const notFilter = notFilterIds.length
     ? { not: { id: { in: notFilterIds } } }
     : undefined;
@@ -63,11 +63,11 @@ export const useFilteredSearchEntityQuery = ({
     });
 
   return {
-    selectedEntities: selectedRecords.map(mappingFunction).filter(isDefined),
-    filteredSelectedEntities: filteredSelectedRecords
+    selectedRecords: selectedRecords.map(mappingFunction).filter(isDefined),
+    filteredSelectedRecords: filteredSelectedRecords
       .map(mappingFunction)
       .filter(isDefined),
-    entitiesToSelect: recordsToSelect.map(mappingFunction).filter(isDefined),
+    recordsToSelect: recordsToSelect.map(mappingFunction).filter(isDefined),
     loading:
       recordsToSelectLoading ||
       filteredSelectedRecordsLoading ||