[GroupBy] Add views filters to groupBy query 2/2: handle anyFieldFilter (#14791)

Following https://github.com/twentyhq/twenty/pull/14762 

In this PR
- moved logic around any field filter formatting to twenty-shared
- added any field filter to the filters applied to groupBy when viewId
is defined
- added integration test

packages/twenty-front/src/modules/object-record/multiple-objects/hooks/useGenerateCombinedFindManyRecordsQuery.ts

@@ -1,5 +1,5 @@
 import { gql } from '@apollo/client';
-import { isUndefined } from '@sniptt/guards';
+import { isNonEmptyArray, isUndefined } from '@sniptt/guards';
 import { useRecoilValue } from 'recoil';
 
 import { objectMetadataItemsState } from '@/object-metadata/states/objectMetadataItemsState';
@@ -11,7 +11,6 @@ import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions
 import { getCombinedFindManyRecordsQueryFilteringPart } from '@/object-record/multiple-objects/utils/getCombinedFindManyRecordsQueryFilteringPart';
 import isEmpty from 'lodash.isempty';
 import { capitalize } from 'twenty-shared/utils';
-import { isNonEmptyArray } from '~/utils/isNonEmptyArray';
 
 export const useGenerateCombinedFindManyRecordsQuery = ({
   operationSignatures,

packages/twenty-front/src/modules/object-record/multiple-objects/utils/generateCombinedFindManyRecordsQueryVariables.ts

@@ -1,7 +1,6 @@
 import { type RecordGqlOperationSignature } from '@/object-record/graphql/types/RecordGqlOperationSignature';
 import { isNonEmptyString } from '@sniptt/guards';
-import { isNonEmptyArray } from '~/utils/isNonEmptyArray';
-import { capitalize, isDefined } from 'twenty-shared/utils';
+import { capitalize, isDefined, isNonEmptyArray } from 'twenty-shared/utils';
 
 export const generateCombinedFindManyRecordsQueryVariables = ({
   operationSignatures,

packages/twenty-front/src/modules/object-record/record-field/ui/form-types/components/FormCurrencyFieldInput.tsx

@@ -3,11 +3,11 @@ import { FormNestedFieldInputContainer } from '@/object-record/record-field/ui/f
 import { FormNumberFieldInput } from '@/object-record/record-field/ui/form-types/components/FormNumberFieldInput';
 import { FormSelectFieldInput } from '@/object-record/record-field/ui/form-types/components/FormSelectFieldInput';
 import { type VariablePickerComponent } from '@/object-record/record-field/ui/form-types/types/VariablePickerComponent';
-import { type CurrencyCode } from '@/object-record/record-field/ui/types/CurrencyCode';
 import { type FormFieldCurrencyValue } from '@/object-record/record-field/ui/types/FieldMetadata';
 import { CURRENCIES } from '@/settings/data-model/constants/Currencies';
 import { InputLabel } from '@/ui/input/components/InputLabel';
 import { useMemo } from 'react';
+import { type CurrencyCode } from 'twenty-shared/constants';
 import { IconCircleOff } from 'twenty-ui/display';
 
 type FormCurrencyFieldInputProps = {

packages/twenty-front/src/modules/object-record/record-field/ui/form-types/components/__stories__/FormCurrencyFieldInput.stories.tsx

@@ -1,7 +1,7 @@
-import { CurrencyCode } from '@/object-record/record-field/ui/types/CurrencyCode';
 import { type FieldCurrencyValue } from '@/object-record/record-field/ui/types/FieldMetadata';
 import { type Meta, type StoryObj } from '@storybook/react';
 import { expect, within } from '@storybook/test';
+import { CurrencyCode } from 'twenty-shared/constants';
 import { I18nFrontDecorator } from '~/testing/decorators/I18nFrontDecorator';
 import { WorkflowStepDecorator } from '~/testing/decorators/WorkflowStepDecorator';
 import { MOCKED_STEP_ID } from '~/testing/mock-data/workflow';

packages/twenty-front/src/modules/object-record/record-field/ui/meta-types/input/components/CurrencyFieldInput.tsx

@@ -1,8 +1,8 @@
 import { isNonEmptyString } from '@sniptt/guards';
 
-import { CurrencyCode } from '@/object-record/record-field/ui/types/CurrencyCode';
 import { type FieldCurrencyValue } from '@/object-record/record-field/ui/types/FieldMetadata';
 import { CurrencyInput } from '@/ui/field/input/components/CurrencyInput';
+import { CurrencyCode } from 'twenty-shared/constants';
 
 import { useCurrencyField } from '../../hooks/useCurrencyField';
 

packages/twenty-front/src/modules/object-record/record-field/ui/types/CurrencyCode.ts

@@ -1,155 +0,0 @@
-export enum CurrencyCode {
-  AED = 'AED',
-  AFN = 'AFN',
-  ALL = 'ALL',
-  AMD = 'AMD',
-  ANG = 'ANG',
-  AOA = 'AOA',
-  ARS = 'ARS',
-  AUD = 'AUD',
-  AWG = 'AWG',
-  AZN = 'AZN',
-  BAM = 'BAM',
-  BBD = 'BBD',
-  BDT = 'BDT',
-  BGN = 'BGN',
-  BHD = 'BHD',
-  BIF = 'BIF',
-  BMD = 'BMD',
-  BND = 'BND',
-  BOB = 'BOB',
-  BRL = 'BRL',
-  BSD = 'BSD',
-  BTN = 'BTN',
-  BWP = 'BWP',
-  BYN = 'BYN',
-  BZD = 'BZD',
-  CAD = 'CAD',
-  CDF = 'CDF',
-  CHF = 'CHF',
-  CLP = 'CLP',
-  CNY = 'CNY',
-  COP = 'COP',
-  CRC = 'CRC',
-  CUP = 'CUP',
-  CVE = 'CVE',
-  CZK = 'CZK',
-  DJF = 'DJF',
-  DKK = 'DKK',
-  DOP = 'DOP',
-  DZD = 'DZD',
-  EGP = 'EGP',
-  ERN = 'ERN',
-  ETB = 'ETB',
-  EUR = 'EUR',
-  FJD = 'FJD',
-  FKP = 'FKP',
-  GBP = 'GBP',
-  GEL = 'GEL',
-  GHS = 'GHS',
-  GIP = 'GIP',
-  GMD = 'GMD',
-  GNF = 'GNF',
-  GTQ = 'GTQ',
-  GYD = 'GYD',
-  HKD = 'HKD',
-  HNL = 'HNL',
-  HTG = 'HTG',
-  HUF = 'HUF',
-  IDR = 'IDR',
-  ILS = 'ILS',
-  INR = 'INR',
-  IQD = 'IQD',
-  IRR = 'IRR',
-  ISK = 'ISK',
-  JMD = 'JMD',
-  JOD = 'JOD',
-  JPY = 'JPY',
-  KES = 'KES',
-  KGS = 'KGS',
-  KHR = 'KHR',
-  KMF = 'KMF',
-  KPW = 'KPW',
-  KRW = 'KRW',
-  KWD = 'KWD',
-  KYD = 'KYD',
-  KZT = 'KZT',
-  LAK = 'LAK',
-  LBP = 'LBP',
-  LKR = 'LKR',
-  LRD = 'LRD',
-  LSL = 'LSL',
-  LYD = 'LYD',
-  MAD = 'MAD',
-  MDL = 'MDL',
-  MGA = 'MGA',
-  MKD = 'MKD',
-  MMK = 'MMK',
-  MNT = 'MNT',
-  MOP = 'MOP',
-  MRU = 'MRU',
-  MUR = 'MUR',
-  MVR = 'MVR',
-  MWK = 'MWK',
-  MXN = 'MXN',
-  MYR = 'MYR',
-  MZN = 'MZN',
-  NAD = 'NAD',
-  NGN = 'NGN',
-  NIO = 'NIO',
-  NOK = 'NOK',
-  NPR = 'NPR',
-  NZD = 'NZD',
-  OMR = 'OMR',
-  PAB = 'PAB',
-  PEN = 'PEN',
-  PGK = 'PGK',
-  PHP = 'PHP',
-  PKR = 'PKR',
-  PLN = 'PLN',
-  PYG = 'PYG',
-  QAR = 'QAR',
-  RON = 'RON',
-  RSD = 'RSD',
-  RUB = 'RUB',
-  RWF = 'RWF',
-  SAR = 'SAR',
-  SBD = 'SBD',
-  SCR = 'SCR',
-  SDG = 'SDG',
-  SEK = 'SEK',
-  SGD = 'SGD',
-  SHP = 'SHP',
-  SLE = 'SLE',
-  SOS = 'SOS',
-  SRD = 'SRD',
-  SSP = 'SSP',
-  STN = 'STN',
-  SVC = 'SVC',
-  SYP = 'SYP',
-  SZL = 'SZL',
-  THB = 'THB',
-  TJS = 'TJS',
-  TMT = 'TMT',
-  TND = 'TND',
-  TOP = 'TOP',
-  TRY = 'TRY',
-  TTD = 'TTD',
-  TWD = 'TWD',
-  TZS = 'TZS',
-  UAH = 'UAH',
-  UGX = 'UGX',
-  USD = 'USD',
-  UYU = 'UYU',
-  UZS = 'UZS',
-  VES = 'VES',
-  VND = 'VND',
-  VUV = 'VUV',
-  WST = 'WST',
-  XCD = 'XCD',
-  XOF = 'XOF',
-  YER = 'YER',
-  ZAR = 'ZAR',
-  ZMW = 'ZMW',
-  ZWG = 'ZWG',
-}

packages/twenty-front/src/modules/object-record/record-field/ui/types/FieldInputDraftValue.ts

@@ -1,4 +1,3 @@
-import { type CurrencyCode } from '@/object-record/record-field/ui/types/CurrencyCode';
 import {
   type FieldActorValue,
   type FieldAddressValue,
@@ -19,6 +18,7 @@ import {
   type FieldUUidValue,
   type PhoneRecord,
 } from '@/object-record/record-field/ui/types/FieldMetadata';
+import { type CurrencyCode } from 'twenty-shared/constants';
 import { type FieldRatingValue } from 'twenty-shared/types';
 
 export type FieldTextDraftValue = string;

packages/twenty-front/src/modules/object-record/record-field/ui/types/FieldMetadata.ts

@@ -1,6 +1,7 @@
 import { type FieldMetadataItemRelation } from '@/object-metadata/types/FieldMetadataItemRelation';
 import { type ZodHelperLiteral } from '@/object-record/record-field/ui/types/ZodHelperLiteral';
 import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
+import { type CurrencyCode } from 'twenty-shared/constants';
 import {
   ConnectedAccountProvider,
   type AllowedAddressSubField,
@@ -8,7 +9,6 @@ import {
 import { type ThemeColor } from 'twenty-ui/theme';
 import { z } from 'zod';
 import { type RelationType } from '~/generated-metadata/graphql';
-import { type CurrencyCode } from './CurrencyCode';
 
 type BaseFieldMetadata = {
   fieldName: string;

packages/twenty-front/src/modules/object-record/record-field/ui/types/guards/isFieldCurrencyValue.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
-import { CurrencyCode } from '../CurrencyCode';
+import { CurrencyCode } from 'twenty-shared/constants';
 import { type FieldCurrencyValue } from '../FieldMetadata';
 
 const currencySchema = z.object({

packages/twenty-front/src/modules/object-record/record-field/ui/utils/computeDraftValueFromString.ts

@@ -1,4 +1,3 @@
-import { CurrencyCode } from '@/object-record/record-field/ui/types/CurrencyCode';
 import { type FieldDefinition } from '@/object-record/record-field/ui/types/FieldDefinition';
 import { type FieldInputDraftValue } from '@/object-record/record-field/ui/types/FieldInputDraftValue';
 import { type FieldMetadata } from '@/object-record/record-field/ui/types/FieldMetadata';
@@ -13,6 +12,7 @@ import { isFieldPhones } from '@/object-record/record-field/ui/types/guards/isFi
 import { isFieldRelation } from '@/object-record/record-field/ui/types/guards/isFieldRelation';
 import { isFieldText } from '@/object-record/record-field/ui/types/guards/isFieldText';
 import { isFieldUuid } from '@/object-record/record-field/ui/types/guards/isFieldUuid';
+import { CurrencyCode } from 'twenty-shared/constants';
 import { CustomError } from 'twenty-shared/utils';
 
 type computeDraftValueFromStringParams = {

packages/twenty-front/src/modules/object-record/record-field/ui/utils/computeEmptyDraftValue.ts

@@ -1,4 +1,3 @@
-import { CurrencyCode } from '@/object-record/record-field/ui/types/CurrencyCode';
 import { type FieldDefinition } from '@/object-record/record-field/ui/types/FieldDefinition';
 import { type FieldInputDraftValue } from '@/object-record/record-field/ui/types/FieldInputDraftValue';
 import { type FieldMetadata } from '@/object-record/record-field/ui/types/FieldMetadata';
@@ -12,6 +11,7 @@ import { isFieldRawJson } from '@/object-record/record-field/ui/types/guards/isF
 import { isFieldRelation } from '@/object-record/record-field/ui/types/guards/isFieldRelation';
 import { isFieldText } from '@/object-record/record-field/ui/types/guards/isFieldText';
 import { isFieldUuid } from '@/object-record/record-field/ui/types/guards/isFieldUuid';
+import { CurrencyCode } from 'twenty-shared/constants';
 import { CustomError } from 'twenty-shared/utils';
 
 type computeEmptyDraftValueParams = {

packages/twenty-front/src/modules/object-record/record-field/ui/validation-schemas/currencyCodeSchema.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
 
-import { CurrencyCode } from '@/object-record/record-field/ui/types/CurrencyCode';
+import { CurrencyCode } from 'twenty-shared/constants';
 
 export const currencyCodeSchema = z.enum(CurrencyCode);

packages/twenty-front/src/modules/object-record/record-field/ui/validation-schemas/currencyFieldDefaultValueSchema.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
-import { type CurrencyCode } from '@/object-record/record-field/ui/types/CurrencyCode';
 import { currencyCodeSchema } from '@/object-record/record-field/ui/validation-schemas/currencyCodeSchema';
+import { type CurrencyCode } from 'twenty-shared/constants';
 import { stripSimpleQuotesFromString } from '~/utils/string/stripSimpleQuotesFromString';
 import { simpleQuotesStringSchema } from '~/utils/validation-schemas/simpleQuotesStringSchema';
 

packages/twenty-front/src/modules/object-record/record-filter/utils/__tests__/turnAnyFieldFilterIntoRecordGqlFilter.test.ts

@@ -1,606 +0,0 @@
-import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
-import { type ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
-import { filterSelectOptionsOfFieldMetadataItem } from '@/object-record/record-filter/utils/filterSelectOptionsOfFieldMetadataItem';
-import { turnAnyFieldFilterIntoRecordGqlFilter } from '@/object-record/record-filter/utils/turnAnyFieldFilterIntoRecordGqlFilter';
-import { FieldMetadataType } from '~/generated-metadata/graphql';
-
-const baseFieldMetadataItem: FieldMetadataItem = {
-  id: 'base-field-metadata-item-id',
-  createdAt: new Date().toISOString(),
-  label: 'Test',
-  name: 'test',
-  type: FieldMetadataType.TEXT,
-  updatedAt: new Date().toISOString(),
-};
-
-const textFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'text-field-id',
-  name: 'textField',
-};
-
-const addressFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'address-field-id',
-  type: FieldMetadataType.ADDRESS,
-  name: 'addressField',
-};
-
-const linksFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'links-field-id',
-  type: FieldMetadataType.LINKS,
-  name: 'linksField',
-};
-
-const fullNameFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'full-name-field-id',
-  type: FieldMetadataType.FULL_NAME,
-  name: 'fullNameField',
-};
-
-const arrayFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'array-field-id',
-  type: FieldMetadataType.ARRAY,
-  name: 'arrayField',
-};
-
-const emailsFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'emails-field-id',
-  type: FieldMetadataType.EMAILS,
-  name: 'emailsField',
-};
-
-const phonesFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'phones-field-id',
-  type: FieldMetadataType.PHONES,
-  name: 'phonesField',
-};
-
-const numberFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'number-field-id',
-  type: FieldMetadataType.NUMBER,
-  name: 'numberField',
-};
-
-const currencyFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'currency-field-id',
-  type: FieldMetadataType.CURRENCY,
-  name: 'currencyField',
-};
-
-const selectFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'select-field-id',
-  type: FieldMetadataType.SELECT,
-  name: 'selectField',
-  options: [
-    {
-      color: 'blue',
-      id: '1',
-      label: 'blue',
-      position: 1,
-      value: 'BLUE',
-    },
-    {
-      color: 'red',
-      id: '2',
-      label: 'red',
-      position: 2,
-      value: 'RED',
-    },
-  ],
-};
-
-const multiSelectFieldMetadataItem: FieldMetadataItem = {
-  ...baseFieldMetadataItem,
-  id: 'multi-select-field-id',
-  type: FieldMetadataType.MULTI_SELECT,
-  name: 'multiSelect',
-  options: [
-    {
-      color: 'blue',
-      id: '1',
-      label: 'blue',
-      position: 1,
-      value: 'BLUE',
-    },
-    {
-      color: 'red',
-      id: '2',
-      label: 'red',
-      position: 2,
-      value: 'RED',
-    },
-  ],
-};
-
-const mockObjectMetadataItem: ObjectMetadataItem = {
-  id: 'mock-object-metadata-item',
-  createdAt: new Date().toISOString(),
-  updatedAt: new Date().toISOString(),
-  indexMetadatas: [],
-  isActive: true,
-  isCustom: true,
-  isLabelSyncedWithName: true,
-  isRemote: false,
-  isSearchable: true,
-  isSystem: false,
-  isUIReadOnly: false,
-  labelIdentifierFieldMetadataId: 'mock-id',
-  labelPlural: 'Tests',
-  labelSingular: 'Test',
-  nameSingular: 'test',
-  namePlural: 'tests',
-  fields: [],
-  readableFields: [],
-  updatableFields: [],
-};
-
-const mockObjectMetadataItemWithAllFields: ObjectMetadataItem = {
-  ...mockObjectMetadataItem,
-  fields: [
-    textFieldMetadataItem,
-    addressFieldMetadataItem,
-    linksFieldMetadataItem,
-    fullNameFieldMetadataItem,
-    arrayFieldMetadataItem,
-    emailsFieldMetadataItem,
-    phonesFieldMetadataItem,
-    numberFieldMetadataItem,
-    currencyFieldMetadataItem,
-    selectFieldMetadataItem,
-    multiSelectFieldMetadataItem,
-  ],
-};
-
-describe('turnAnyFieldFilterIntoRecordGqlFilter', () => {
-  describe('TEXT field type', () => {
-    it('should generate correct filter for text field', () => {
-      const filterValue = 'test';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [textFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        [textFieldMetadataItem.name]: {
-          ilike: `%${filterValue}%`,
-        },
-      });
-    });
-  });
-
-  describe('ADDRESS field type', () => {
-    it('should generate correct filter for address field', () => {
-      const filterValue = 'New York';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [addressFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        or: [
-          {
-            [addressFieldMetadataItem.name]: {
-              addressStreet1: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [addressFieldMetadataItem.name]: {
-              addressStreet2: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [addressFieldMetadataItem.name]: {
-              addressCity: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [addressFieldMetadataItem.name]: {
-              addressState: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [addressFieldMetadataItem.name]: {
-              addressCountry: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [addressFieldMetadataItem.name]: {
-              addressPostcode: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-        ],
-      });
-    });
-  });
-
-  describe('LINKS field type', () => {
-    it('should generate correct filter for links field', () => {
-      const filterValue = 'test';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [linksFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        or: [
-          {
-            [linksFieldMetadataItem.name]: {
-              primaryLinkUrl: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [linksFieldMetadataItem.name]: {
-              primaryLinkLabel: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [linksFieldMetadataItem.name]: {
-              secondaryLinks: {
-                like: `%${filterValue}%`,
-              },
-            },
-          },
-        ],
-      });
-    });
-  });
-
-  describe('FULL_NAME field type', () => {
-    it('should generate correct filter for full name field', () => {
-      const filterValue = 'test';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [fullNameFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        or: [
-          {
-            [fullNameFieldMetadataItem.name]: {
-              firstName: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [fullNameFieldMetadataItem.name]: {
-              lastName: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-        ],
-      });
-    });
-  });
-
-  describe('ARRAY field type', () => {
-    it('should generate correct filter for array field', () => {
-      const filterValue = 'test';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [arrayFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        [arrayFieldMetadataItem.name]: {
-          containsIlike: `%${filterValue}%`,
-        },
-      });
-    });
-  });
-
-  describe('EMAILS field type', () => {
-    it('should generate correct filter for emails field', () => {
-      const filterValue = 'test';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [emailsFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        or: [
-          {
-            [emailsFieldMetadataItem.name]: {
-              primaryEmail: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [emailsFieldMetadataItem.name]: {
-              additionalEmails: {
-                like: `%${filterValue}%`,
-              },
-            },
-          },
-        ],
-      });
-    });
-  });
-
-  describe('PHONES field type', () => {
-    it('should generate correct filter for phones field', () => {
-      const filterValue = '123';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [phonesFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        or: [
-          {
-            [phonesFieldMetadataItem.name]: {
-              primaryPhoneNumber: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [phonesFieldMetadataItem.name]: {
-              primaryPhoneCallingCode: {
-                ilike: `%${filterValue}%`,
-              },
-            },
-          },
-          {
-            [phonesFieldMetadataItem.name]: {
-              additionalPhones: {
-                like: `%${filterValue}%`,
-              },
-            },
-          },
-        ],
-      });
-    });
-  });
-
-  describe('NUMBER field type', () => {
-    it('should generate correct filter for number field with numeric value', () => {
-      const filterValue = '123.1';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [numberFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        [numberFieldMetadataItem.name]: {
-          eq: 123.1,
-        },
-      });
-    });
-
-    it('should not generate filter for number field with non-numeric value', () => {
-      const filterValue = 'not a number';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [numberFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter).toEqual({});
-    });
-  });
-
-  describe('CURRENCY field type', () => {
-    it('should generate correct filter for currency field with numeric value', () => {
-      const filterValue = '123';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [currencyFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        [currencyFieldMetadataItem.name]: {
-          amountMicros: {
-            eq: 123000000,
-          },
-        },
-      });
-    });
-
-    it('should generate correct filter for currency field with currency code', () => {
-      const filterValue = 'USD';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [currencyFieldMetadataItem],
-        },
-      });
-
-      expect(
-        (result.recordGqlOperationFilter.or as any)?.[0][
-          currencyFieldMetadataItem.name
-        ].currencyCode.in.includes(filterValue),
-      ).toBe(true);
-    });
-  });
-
-  describe('SELECT field type', () => {
-    it('should generate correct filter for select field with matching option', () => {
-      const filterValue = 'r';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [selectFieldMetadataItem],
-        },
-      });
-
-      const { foundCorrespondingSelectOptions: expectedOptions } =
-        filterSelectOptionsOfFieldMetadataItem({
-          fieldMetadataItem: selectFieldMetadataItem,
-          filterValue,
-        });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        [selectFieldMetadataItem.name]: {
-          in: expectedOptions?.map((option) => option.value),
-        },
-      });
-    });
-
-    it('should not generate filter for select field with non-matching value', () => {
-      const filterValue = 'not-found';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [selectFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter).toEqual({});
-    });
-  });
-
-  describe('MULTI_SELECT field type', () => {
-    it('should generate correct filter for multi-select field with matching option', () => {
-      const filterValue = 'r';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [multiSelectFieldMetadataItem],
-        },
-      });
-
-      const { foundCorrespondingSelectOptions: expectedOptions } =
-        filterSelectOptionsOfFieldMetadataItem({
-          fieldMetadataItem: multiSelectFieldMetadataItem,
-          filterValue,
-        });
-
-      expect(result.recordGqlOperationFilter.or).toContainEqual({
-        [multiSelectFieldMetadataItem.name]: {
-          containsAny: expectedOptions?.map((option) => option.value),
-        },
-      });
-    });
-
-    it('should not generate filter for multi-select field with non-matching value', () => {
-      const filterValue = 'not-found';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: {
-          ...mockObjectMetadataItem,
-          fields: [multiSelectFieldMetadataItem],
-        },
-      });
-
-      expect(result.recordGqlOperationFilter).toEqual({});
-    });
-  });
-
-  describe('combined field filters', () => {
-    it('should generate OR filter combining all matching field types', () => {
-      const filterValue = 'a';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: mockObjectMetadataItemWithAllFields,
-      });
-
-      expect(result.recordGqlOperationFilter).toHaveProperty('or');
-      expect(Array.isArray(result.recordGqlOperationFilter.or)).toBe(true);
-      expect(
-        (result.recordGqlOperationFilter.or as any[])?.length,
-      ).toBeGreaterThan(0);
-    });
-
-    it('should handle empty filter value', () => {
-      const filterValue = '';
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue,
-        objectMetadataItem: mockObjectMetadataItemWithAllFields,
-      });
-
-      expect(result.recordGqlOperationFilter).toEqual({});
-    });
-
-    it('should handle object with no fields', () => {
-      const emptyObjectMetadata = {
-        ...mockObjectMetadataItem,
-        fields: [],
-      };
-
-      const result = turnAnyFieldFilterIntoRecordGqlFilter({
-        filterValue: 'test',
-        objectMetadataItem: emptyObjectMetadata,
-      });
-
-      expect(result.recordGqlOperationFilter).toEqual({});
-    });
-  });
-});

packages/twenty-front/src/modules/object-record/record-filter/utils/createAnyFieldRecordFilterBaseProperties.ts

@@ -1,22 +0,0 @@
-import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
-import { type RecordFilter } from '@/object-record/record-filter/types/RecordFilter';
-import { v4 } from 'uuid';
-
-export const createAnyFieldRecordFilterBaseProperties = ({
-  filterValue,
-  fieldMetadataItem,
-}: {
-  filterValue: string;
-  fieldMetadataItem: FieldMetadataItem;
-}): Pick<
-  RecordFilter,
-  'id' | 'value' | 'displayValue' | 'label' | 'fieldMetadataId'
-> => {
-  return {
-    id: v4(),
-    value: filterValue,
-    displayValue: '',
-    label: '',
-    fieldMetadataId: fieldMetadataItem.id,
-  };
-};

packages/twenty-front/src/modules/object-record/record-filter/utils/filterSelectOptionsOfFieldMetadataItem.ts

@@ -1,25 +0,0 @@
-import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
-
-export const filterSelectOptionsOfFieldMetadataItem = ({
-  fieldMetadataItem,
-  filterValue,
-}: {
-  fieldMetadataItem: FieldMetadataItem;
-  filterValue: string;
-}) => {
-  const selectOptions = fieldMetadataItem.options;
-
-  const foundCorrespondingSelectOptions = selectOptions?.filter(
-    (selectOption) =>
-      selectOption.value
-        .toLocaleLowerCase()
-        .includes(filterValue.toLocaleLowerCase()) ||
-      selectOption.label
-        .toLocaleLowerCase()
-        .includes(filterValue.toLocaleLowerCase()),
-  );
-
-  return {
-    foundCorrespondingSelectOptions,
-  };
-};

packages/twenty-front/src/modules/object-record/record-filter/utils/turnAnyFieldFilterIntoRecordGqlFilter.ts

@@ -1,238 +0,0 @@
-import { type ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
-import { type RecordFilter } from '@/object-record/record-filter/types/RecordFilter';
-import { RecordFilterOperand } from '@/object-record/record-filter/types/RecordFilterOperand';
-import { createAnyFieldRecordFilterBaseProperties } from '@/object-record/record-filter/utils/createAnyFieldRecordFilterBaseProperties';
-import { filterSelectOptionsOfFieldMetadataItem } from '@/object-record/record-filter/utils/filterSelectOptionsOfFieldMetadataItem';
-import { CURRENCIES } from '@/settings/data-model/constants/Currencies';
-import { isNonEmptyString } from '@sniptt/guards';
-import { type RecordGqlOperationFilter } from 'twenty-shared/types';
-import {
-  isDefined,
-  turnRecordFilterIntoRecordGqlOperationFilter,
-} from 'twenty-shared/utils';
-import { z } from 'zod';
-import { FieldMetadataType } from '~/generated-metadata/graphql';
-import { isNonEmptyArray } from '~/utils/isNonEmptyArray';
-
-export const turnAnyFieldFilterIntoRecordGqlFilter = ({
-  filterValue,
-  objectMetadataItem,
-}: {
-  filterValue: string;
-  objectMetadataItem: ObjectMetadataItem;
-}) => {
-  const fieldMetadataItems = objectMetadataItem.fields;
-
-  const anyFieldRecordFilters: RecordFilter[] = [];
-
-  const isFilterValueANumber = z.coerce.number().safeParse(filterValue).success;
-
-  for (const fieldMetadataItem of fieldMetadataItems) {
-    switch (fieldMetadataItem.type) {
-      case FieldMetadataType.TEXT: {
-        anyFieldRecordFilters.push({
-          ...createAnyFieldRecordFilterBaseProperties({
-            filterValue,
-            fieldMetadataItem,
-          }),
-          operand: RecordFilterOperand.CONTAINS,
-          type: 'TEXT',
-        } satisfies RecordFilter);
-        break;
-      }
-      case FieldMetadataType.ADDRESS: {
-        anyFieldRecordFilters.push({
-          ...createAnyFieldRecordFilterBaseProperties({
-            filterValue,
-            fieldMetadataItem,
-          }),
-          operand: RecordFilterOperand.CONTAINS,
-          type: 'ADDRESS',
-        } satisfies RecordFilter);
-        break;
-      }
-      case FieldMetadataType.LINKS: {
-        anyFieldRecordFilters.push({
-          ...createAnyFieldRecordFilterBaseProperties({
-            filterValue,
-            fieldMetadataItem,
-          }),
-          operand: RecordFilterOperand.CONTAINS,
-          type: 'LINKS',
-        } satisfies RecordFilter);
-        break;
-      }
-      case FieldMetadataType.FULL_NAME: {
-        anyFieldRecordFilters.push({
-          ...createAnyFieldRecordFilterBaseProperties({
-            filterValue,
-            fieldMetadataItem,
-          }),
-          operand: RecordFilterOperand.CONTAINS,
-          type: 'FULL_NAME',
-        } satisfies RecordFilter);
-        break;
-      }
-      case FieldMetadataType.ARRAY: {
-        anyFieldRecordFilters.push({
-          ...createAnyFieldRecordFilterBaseProperties({
-            filterValue,
-            fieldMetadataItem,
-          }),
-          operand: RecordFilterOperand.CONTAINS,
-          type: 'ARRAY',
-        } satisfies RecordFilter);
-        break;
-      }
-      case FieldMetadataType.EMAILS: {
-        anyFieldRecordFilters.push({
-          ...createAnyFieldRecordFilterBaseProperties({
-            filterValue,
-            fieldMetadataItem,
-          }),
-          operand: RecordFilterOperand.CONTAINS,
-          type: 'EMAILS',
-        } satisfies RecordFilter);
-        break;
-      }
-      case FieldMetadataType.PHONES: {
-        anyFieldRecordFilters.push({
-          ...createAnyFieldRecordFilterBaseProperties({
-            filterValue,
-            fieldMetadataItem,
-          }),
-          operand: RecordFilterOperand.CONTAINS,
-          type: 'PHONES',
-        } satisfies RecordFilter);
-        break;
-      }
-      case FieldMetadataType.NUMBER: {
-        if (isFilterValueANumber) {
-          anyFieldRecordFilters.push({
-            ...createAnyFieldRecordFilterBaseProperties({
-              filterValue,
-              fieldMetadataItem,
-            }),
-            operand: RecordFilterOperand.IS,
-            type: 'NUMBER',
-          } satisfies RecordFilter);
-        }
-        break;
-      }
-      case FieldMetadataType.CURRENCY: {
-        if (isFilterValueANumber) {
-          anyFieldRecordFilters.push({
-            ...createAnyFieldRecordFilterBaseProperties({
-              filterValue,
-              fieldMetadataItem,
-            }),
-            operand: RecordFilterOperand.IS,
-            type: 'CURRENCY',
-            subFieldName: 'amountMicros',
-          } satisfies RecordFilter);
-        }
-
-        if (isNonEmptyString(filterValue)) {
-          const foundCorrespondingCurrencies = CURRENCIES.filter(
-            (currency) =>
-              currency.label.includes(filterValue) ||
-              currency.value.includes(filterValue),
-          );
-
-          if (isNonEmptyArray(foundCorrespondingCurrencies)) {
-            const arrayOfCurrenciesStringified = JSON.stringify(
-              foundCorrespondingCurrencies.map((currency) => currency.value),
-            );
-
-            anyFieldRecordFilters.push({
-              ...createAnyFieldRecordFilterBaseProperties({
-                filterValue: arrayOfCurrenciesStringified,
-                fieldMetadataItem,
-              }),
-              operand: RecordFilterOperand.IS,
-              type: 'CURRENCY',
-              subFieldName: 'currencyCode',
-            } satisfies RecordFilter);
-          }
-        }
-        break;
-      }
-      case FieldMetadataType.SELECT: {
-        if (isNonEmptyString(filterValue)) {
-          const { foundCorrespondingSelectOptions } =
-            filterSelectOptionsOfFieldMetadataItem({
-              fieldMetadataItem,
-              filterValue,
-            });
-
-          if (isNonEmptyArray(foundCorrespondingSelectOptions)) {
-            const arrayOfSelectValues = JSON.stringify(
-              foundCorrespondingSelectOptions.map(
-                (selectOption) => selectOption.value,
-              ),
-            );
-
-            anyFieldRecordFilters.push({
-              ...createAnyFieldRecordFilterBaseProperties({
-                fieldMetadataItem,
-                filterValue: arrayOfSelectValues,
-              }),
-              operand: RecordFilterOperand.IS,
-              type: 'SELECT',
-            } satisfies RecordFilter);
-          }
-        }
-        break;
-      }
-      case FieldMetadataType.MULTI_SELECT: {
-        if (isNonEmptyString(filterValue)) {
-          const { foundCorrespondingSelectOptions } =
-            filterSelectOptionsOfFieldMetadataItem({
-              fieldMetadataItem,
-              filterValue,
-            });
-
-          if (isNonEmptyArray(foundCorrespondingSelectOptions)) {
-            const arrayOfSelectValues = JSON.stringify(
-              foundCorrespondingSelectOptions.map(
-                (selectOption) => selectOption.value,
-              ),
-            );
-
-            anyFieldRecordFilters.push({
-              ...createAnyFieldRecordFilterBaseProperties({
-                fieldMetadataItem,
-                filterValue: arrayOfSelectValues,
-              }),
-              operand: RecordFilterOperand.CONTAINS,
-              type: 'MULTI_SELECT',
-            } satisfies RecordFilter);
-          }
-        }
-        break;
-      }
-    }
-  }
-
-  const baseRecordGqlOperationFilters = anyFieldRecordFilters
-    .map((recordFilter) =>
-      turnRecordFilterIntoRecordGqlOperationFilter({
-        filterValueDependencies: {},
-        fieldMetadataItems: objectMetadataItem.fields,
-        recordFilter,
-      }),
-    )
-    .filter(isDefined);
-
-  const recordGqlOperationFilter: RecordGqlOperationFilter = {
-    or: baseRecordGqlOperationFilters,
-  };
-
-  if (baseRecordGqlOperationFilters.length === 0) {
-    return { recordGqlOperationFilter: {} };
-  }
-
-  return {
-    recordGqlOperationFilter,
-  };
-};

packages/twenty-front/src/modules/object-record/record-index/hooks/useFindManyRecordIndexTableParams.ts

@@ -4,7 +4,6 @@ import { currentRecordFilterGroupsComponentState } from '@/object-record/record-
 import { useFilterValueDependencies } from '@/object-record/record-filter/hooks/useFilterValueDependencies';
 import { anyFieldFilterValueComponentState } from '@/object-record/record-filter/states/anyFieldFilterValueComponentState';
 import { currentRecordFiltersComponentState } from '@/object-record/record-filter/states/currentRecordFiltersComponentState';
-import { turnAnyFieldFilterIntoRecordGqlFilter } from '@/object-record/record-filter/utils/turnAnyFieldFilterIntoRecordGqlFilter';
 import { useCurrentRecordGroupDefinition } from '@/object-record/record-group/hooks/useCurrentRecordGroupDefinition';
 import { useRecordGroupFilter } from '@/object-record/record-group/hooks/useRecordGroupFilter';
 import { currentRecordSortsComponentState } from '@/object-record/record-sort/states/currentRecordSortsComponentState';
@@ -12,6 +11,7 @@ import { useRecoilComponentValue } from '@/ui/utilities/state/component-state/ho
 import {
   combineFilters,
   computeRecordGqlOperationFilter,
+  turnAnyFieldFilterIntoRecordGqlFilter,
 } from 'twenty-shared/utils';
 export const useFindManyRecordIndexTableParams = (
   objectNameSingular: string,
@@ -53,7 +53,7 @@ export const useFindManyRecordIndexTableParams = (
 
   const { recordGqlOperationFilter: anyFieldFilter } =
     turnAnyFieldFilterIntoRecordGqlFilter({
-      objectMetadataItem,
+      fields: objectMetadataItem?.fields ?? [],
       filterValue: anyFieldFilterValue,
     });
 

packages/twenty-front/src/modules/object-record/record-index/hooks/useLoadRecordIndexBoardColumn.ts

@@ -15,13 +15,13 @@ import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataIte
 import { currentRecordSortsComponentState } from '@/object-record/record-sort/states/currentRecordSortsComponentState';
 
 import { anyFieldFilterValueComponentState } from '@/object-record/record-filter/states/anyFieldFilterValueComponentState';
-import { turnAnyFieldFilterIntoRecordGqlFilter } from '@/object-record/record-filter/utils/turnAnyFieldFilterIntoRecordGqlFilter';
 import { useUpsertRecordsInStore } from '@/object-record/record-store/hooks/useUpsertRecordsInStore';
 import { useRecoilComponentValue } from '@/ui/utilities/state/component-state/hooks/useRecoilComponentValue';
 import {
   combineFilters,
   computeRecordGqlOperationFilter,
   isDefined,
+  turnAnyFieldFilterIntoRecordGqlFilter,
 } from 'twenty-shared/utils';
 
 type UseLoadRecordIndexBoardProps = {
@@ -74,7 +74,7 @@ export const useLoadRecordIndexBoardColumn = ({
 
   const { recordGqlOperationFilter: anyFieldFilter } =
     turnAnyFieldFilterIntoRecordGqlFilter({
-      objectMetadataItem,
+      fields: objectMetadataItem.fields,
       filterValue: anyFieldFilterValue,
     });
 

packages/twenty-front/src/modules/object-record/record-table/hooks/useAggregateRecordsForHeader.ts

@@ -6,7 +6,6 @@ import { currentRecordFilterGroupsComponentState } from '@/object-record/record-
 import { useFilterValueDependencies } from '@/object-record/record-filter/hooks/useFilterValueDependencies';
 import { anyFieldFilterValueComponentState } from '@/object-record/record-filter/states/anyFieldFilterValueComponentState';
 import { currentRecordFiltersComponentState } from '@/object-record/record-filter/states/currentRecordFiltersComponentState';
-import { turnAnyFieldFilterIntoRecordGqlFilter } from '@/object-record/record-filter/utils/turnAnyFieldFilterIntoRecordGqlFilter';
 import { recordIndexKanbanAggregateOperationState } from '@/object-record/record-index/states/recordIndexKanbanAggregateOperationState';
 import { useRecoilComponentValue } from '@/ui/utilities/state/component-state/hooks/useRecoilComponentValue';
 import { UserContext } from '@/users/contexts/UserContext';
@@ -15,6 +14,7 @@ import { useRecoilValue } from 'recoil';
 import {
   computeRecordGqlOperationFilter,
   isDefined,
+  turnAnyFieldFilterIntoRecordGqlFilter,
 } from 'twenty-shared/utils';
 import { dateLocaleState } from '~/localization/states/dateLocaleState';
 
@@ -64,7 +64,7 @@ export const useAggregateRecordsForHeader = ({
 
   const { recordGqlOperationFilter: anyFieldFilter } =
     turnAnyFieldFilterIntoRecordGqlFilter({
-      objectMetadataItem,
+      fields: objectMetadataItem.fields,
       filterValue: anyFieldFilterValue,
     });
 

packages/twenty-front/src/modules/object-record/record-table/record-table-footer/hooks/useAggregateRecordsForRecordTableColumnFooter.tsx

@@ -4,7 +4,6 @@ import { currentRecordFilterGroupsComponentState } from '@/object-record/record-
 import { useFilterValueDependencies } from '@/object-record/record-filter/hooks/useFilterValueDependencies';
 import { anyFieldFilterValueComponentState } from '@/object-record/record-filter/states/anyFieldFilterValueComponentState';
 import { currentRecordFiltersComponentState } from '@/object-record/record-filter/states/currentRecordFiltersComponentState';
-import { turnAnyFieldFilterIntoRecordGqlFilter } from '@/object-record/record-filter/utils/turnAnyFieldFilterIntoRecordGqlFilter';
 import { useRecordGroupFilter } from '@/object-record/record-group/hooks/useRecordGroupFilter';
 import { AggregateOperations } from '@/object-record/record-table/constants/AggregateOperations';
 import { useRecordTableContextOrThrow } from '@/object-record/record-table/contexts/RecordTableContext';
@@ -20,6 +19,7 @@ import {
   computeRecordGqlOperationFilter,
   isDefined,
   isFieldMetadataDateKind,
+  turnAnyFieldFilterIntoRecordGqlFilter,
 } from 'twenty-shared/utils';
 import { dateLocaleState } from '~/localization/states/dateLocaleState';
 
@@ -96,7 +96,7 @@ export const useAggregateRecordsForRecordTableColumnFooter = (
 
   const { recordGqlOperationFilter: anyFieldFilter } =
     turnAnyFieldFilterIntoRecordGqlFilter({
-      objectMetadataItem,
+      fields: objectMetadataItem.fields,
       filterValue: anyFieldFilterValue,
     });
 

packages/twenty-front/src/modules/object-record/record-table/record-table-row/components/RecordTableCellsVisible.tsx

@@ -8,8 +8,7 @@ import { RecordTableCellStyleWrapper } from '@/object-record/record-table/record
 import { RecordTableCellWrapper } from '@/object-record/record-table/record-table-cell/components/RecordTableCellWrapper';
 import { getRecordTableColumnFieldWidthClassName } from '@/object-record/record-table/utils/getRecordTableColumnFieldWidthClassName';
 import { useRecoilComponentValue } from '@/ui/utilities/state/component-state/hooks/useRecoilComponentValue';
-import { isDefined } from 'twenty-shared/utils';
-import { isNonEmptyArray } from '~/utils/isNonEmptyArray';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
 
 export const RecordTableCellsVisible = () => {
   const { isSelected, rowIndex } = useRecordTableRowContextOrThrow();