Skip to content

The open alternative to Salesforce, designed for AI.

Match additional emails, phones and secondary links in optimistic filters (#28327)

Charles Bochet31d95e98a221
diff --git a/packages/twenty-front/src/modules/object-record/record-filter/utils/__tests__/isRecordMatchingFilter.test.ts b/packages/twenty-front/src/modules/object-record/record-filter/utils/__tests__/isRecordMatchingFilter.test.ts
index 55015929b2a..665274205d6 100644
--- a/packages/twenty-front/src/modules/object-record/record-filter/utils/__tests__/isRecordMatchingFilter.test.ts
+++ b/packages/twenty-front/src/modules/object-record/record-filter/utils/__tests__/isRecordMatchingFilter.test.ts
@@ -989,4 +989,141 @@ describe('isRecordMatchingFilter', () => {
).toBe(false);
});
});
+
+ describe('Emails, Phones and Links sub-fields', () => {
+ const personMockObjectMetadataItem = objectMetadataItems.find(
+ (item) => item.nameSingular === 'person',
+ )!;
+
+ const buildPerson = ({
+ additionalEmails = [],
+ primaryPhoneCallingCode = '+1',
+ additionalPhones = [],
+ secondaryLinks = [],
+ }: {
+ additionalEmails?: string[];
+ primaryPhoneCallingCode?: string;
+ additionalPhones?: { number: string; callingCode: string }[];
+ secondaryLinks?: { url: string; label: string }[];
+ }) => ({
+ id: 'person-id',
+ emails: { primaryEmail: '[email protected]', additionalEmails },
+ phones: {
+ primaryPhoneNumber: '612345678',
+ primaryPhoneCountryCode: 'US',
+ primaryPhoneCallingCode,
+ additionalPhones,
+ },
+ linkedinLink: {
+ primaryLinkUrl: 'https://linkedin.com/in/jane',
+ primaryLinkLabel: '',
+ secondaryLinks,
+ },
+ });
+
+ const isMatching = ({
+ record,
+ filter,
+ }: {
+ record: ReturnType<typeof buildPerson>;
+ filter: RecordGqlOperationFilter;
+ }) =>
+ isRecordMatchingFilter({
+ record,
+ filter,
+ objectMetadataItem: personMockObjectMetadataItem,
+ objectMetadataItems,
+ });
+
+ it('matches a filter on additional emails', () => {
+ const filter = { emails: { additionalEmails: { like: '%acme%' } } };
+
+ expect(
+ isMatching({
+ record: buildPerson({ additionalEmails: ['[email protected]'] }),
+ filter,
+ }),
+ ).toBe(true);
+ expect(isMatching({ record: buildPerson({}), filter })).toBe(false);
+ });
+
+ it('matches a filter on the primary phone calling code and additional phones', () => {
+ expect(
+ isMatching({
+ record: buildPerson({ primaryPhoneCallingCode: '+33' }),
+ filter: {
+ phones: { primaryPhoneCallingCode: { like: '%33%' } },
+ },
+ }),
+ ).toBe(true);
+ expect(
+ isMatching({
+ record: buildPerson({
+ additionalPhones: [{ number: '611223344', callingCode: '+44' }],
+ }),
+ filter: { phones: { additionalPhones: { like: '%611223344%' } } },
+ }),
+ ).toBe(true);
+ expect(
+ isMatching({
+ record: buildPerson({}),
+ filter: {
+ phones: { additionalPhones: { like: '%611223344%' } },
+ },
+ }),
+ ).toBe(false);
+ });
+
+ it('matches a filter on secondary links', () => {
+ const filter = {
+ linkedinLink: { secondaryLinks: { like: '%github.com%' } },
+ };
+
+ expect(
+ isMatching({
+ record: buildPerson({
+ secondaryLinks: [{ url: 'https://github.com/jane', label: '' }],
+ }),
+ filter,
+ }),
+ ).toBe(true);
+ expect(isMatching({ record: buildPerson({}), filter })).toBe(false);
+ });
+
+ it('requires every sub-field filter to match, like the server', () => {
+ expect(
+ isMatching({
+ record: buildPerson({ additionalEmails: ['[email protected]'] }),
+ filter: {
+ emails: {
+ primaryEmail: { like: '%example%' },
+ additionalEmails: { like: '%acme%' },
+ },
+ },
+ }),
+ ).toBe(true);
+ expect(
+ isMatching({
+ record: buildPerson({}),
+ filter: {
+ emails: {
+ primaryEmail: { like: '%example%' },
+ additionalEmails: { like: '%acme%' },
+ },
+ },
+ }),
+ ).toBe(false);
+ expect(
+ isMatching({
+ record: buildPerson({}),
+ filter: {
+ linkedinLink: {
+ primaryLinkUrl: { like: '%linkedin.com%' },
+ primaryLinkLabel: { like: '%Jane%' },
+ },
+ },
+ }),
+ ).toBe(false);
+ });
+ });
});
diff --git a/packages/twenty-front/src/modules/object-record/record-filter/utils/isRecordMatchingFilter.ts b/packages/twenty-front/src/modules/object-record/record-filter/utils/isRecordMatchingFilter.ts
index 4c35d618139..27633eb286f 100644
--- a/packages/twenty-front/src/modules/object-record/record-filter/utils/isRecordMatchingFilter.ts
+++ b/packages/twenty-front/src/modules/object-record/record-filter/utils/isRecordMatchingFilter.ts
@@ -2,23 +2,17 @@ import { isObject } from '@sniptt/guards';
import {
FieldMetadataType,
- type ActorFilter,
- type AddressFilter,
type AndObjectRecordFilter,
type ArrayFilter,
type BooleanFilter,
type CurrencyFilter,
type DateFilter,
- type EmailsFilter,
type FilesFilter,
type FloatFilter,
- type FullNameFilter,
type LeafObjectRecordFilter,
- type LinksFilter,
type MultiSelectFilter,
type NotObjectRecordFilter,
type OrObjectRecordFilter,
- type PhonesFilter,
type RatingFilter,
type RawJsonFilter,
type RecordGqlOperationFilter,
@@ -29,11 +23,13 @@ import {
type UUIDFilter,
} from 'twenty-shared/types';
import {
+ COMPOSITE_FIELD_SUB_FIELD_MATCHERS_MAP,
computeRelationGqlFieldJoinColumnName,
isDefined,
isEmptyObject,
isMatchingArrayFilter,
isMatchingBooleanFilter,
+ isMatchingCompositeFilter,
isMatchingCurrencyFilter,
isMatchingDateFilter,
isMatchingFilesFilter,
@@ -360,6 +356,17 @@ export const isRecordMatchingFilter = ({
);
}
+ const subFieldMatchers =
+ COMPOSITE_FIELD_SUB_FIELD_MATCHERS_MAP[objectMetadataField.type];
+
+ if (isDefined(subFieldMatchers)) {
+ return isMatchingCompositeFilter({
+ compositeFilter: filterValue,
+ compositeValue: record[filterKey],
+ subFieldMatchers,
+ });
+ }
+
switch (objectMetadataField.type) {
case FieldMetadataType.RATING:
return isMatchingRatingFilter({
@@ -408,63 +415,6 @@ export const isRecordMatchingFilter = ({
value: record[filterKey],
});
}
- case FieldMetadataType.FULL_NAME: {
- const fullNameFilter = filterValue as FullNameFilter;
-
- return (
- (fullNameFilter.firstName === undefined ||
- isMatchingStringFilter({
- stringFilter: fullNameFilter.firstName,
- value: record[filterKey]?.firstName,
- })) &&
- (fullNameFilter.lastName === undefined ||
- isMatchingStringFilter({
- stringFilter: fullNameFilter.lastName,
- value: record[filterKey]?.lastName,
- }))
- );
- }
- case FieldMetadataType.ADDRESS: {
- const addressFilter = filterValue as AddressFilter;
-
- const keys = [
- 'addressStreet1',
- 'addressStreet2',
- 'addressCity',
- 'addressState',
- 'addressCountry',
- 'addressPostcode',
- ] as const;
-
- return keys.some((key) => {
- const value = addressFilter[key];
- if (value === undefined) {
- return false;
- }
-
- return isMatchingStringFilter({
- stringFilter: value,
- value: record[filterKey]?.[key],
- });
- });
- }
- case FieldMetadataType.LINKS: {
- const linksFilter = filterValue as LinksFilter;
-
- const keys = ['primaryLinkLabel', 'primaryLinkUrl'] as const;
-
- return keys.some((key) => {
- const value = linksFilter[key];
- if (value === undefined) {
- return false;
- }
-
- return isMatchingStringFilter({
- stringFilter: value,
- value: record[filterKey]?.[key],
- });
- });
- }
case FieldMetadataType.DATE:
case FieldMetadataType.DATE_TIME: {
return isMatchingDateFilter({
@@ -498,60 +448,6 @@ export const isRecordMatchingFilter = ({
value: record[filterKey],
});
}
- case FieldMetadataType.ACTOR: {
- const actorFilter = filterValue as ActorFilter;
-
- if (isDefined(actorFilter.workspaceMemberId)) {
- return isMatchingUUIDFilter({
- uuidFilter: actorFilter.workspaceMemberId,
- value: record[filterKey]?.workspaceMemberId,
- });
- }
-
- if (isDefined(actorFilter.source)) {
- return isMatchingSelectFilter({
- selectFilter: actorFilter.source,
- value: record[filterKey].source,
- });
- }
-
- return (
- actorFilter.name === undefined ||
- isMatchingStringFilter({
- stringFilter: actorFilter.name,
- value: record[filterKey]?.name,
- })
- );
- }
- case FieldMetadataType.EMAILS: {
- const emailsFilter = filterValue as EmailsFilter;
-
- if (emailsFilter.primaryEmail === undefined) {
- return false;
- }
-
- return isMatchingStringFilter({
- stringFilter: emailsFilter.primaryEmail,
- value: record[filterKey]?.primaryEmail,
- });
- }
- case FieldMetadataType.PHONES: {
- const phonesFilter = filterValue as PhonesFilter;
-
- const keys: (keyof PhonesFilter)[] = ['primaryPhoneNumber'];
-
- return keys.some((key) => {
- const value = phonesFilter[key];
- if (value === undefined) {
- return false;
- }
-
- return isMatchingStringFilter({
- stringFilter: value,
- value: record[filterKey]?.[key],
- });
- });
- }
case FieldMetadataType.RELATION:
case FieldMetadataType.MORPH_RELATION: {
const isJoinColumn =
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts
index c9e6034962b..4f44c497215 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts
@@ -24,8 +24,10 @@ import {
type UUIDFilter,
} from 'twenty-shared/types';
import {
+ COMPOSITE_FIELD_SUB_FIELD_MATCHERS_MAP,
isDefined,
isEmptyObject,
+ isMatchingCompositeFilter,
isMatchingArrayFilter,
isMatchingBooleanFilter,
isMatchingCurrencyFilter,
@@ -68,115 +70,6 @@ const isNotFilter = (
filter: RecordGqlOperationFilter,
): filter is NotObjectRecordFilter => 'not' in filter && !!filter.not;
-type SubFieldMatcher = (subFieldFilter: object, value: unknown) => boolean;
-
-const matchString: SubFieldMatcher = (subFieldFilter, value) =>
- isMatchingStringFilter({
- stringFilter: subFieldFilter as StringFilter,
- value: value as string,
- });
-
-const matchRawJson: SubFieldMatcher = (subFieldFilter, value) =>
- isMatchingRawJsonFilter({
- rawJsonFilter: subFieldFilter as RawJsonFilter,
- value: value as string,
- });
-
-const matchFloat: SubFieldMatcher = (subFieldFilter, value) =>
- isMatchingFloatFilter({
- floatFilter: subFieldFilter as FloatFilter,
- value: value as number,
- });
-
-const matchSelect: SubFieldMatcher = (subFieldFilter, value) =>
- isMatchingSelectFilter({
- selectFilter: subFieldFilter as SelectFilter,
- value: value as string,
- });
-
-const matchUuid: SubFieldMatcher = (subFieldFilter, value) =>
- isMatchingUUIDFilter({
- uuidFilter: subFieldFilter as UUIDFilter,
- value: value as string,
- });
-
-// Row-level predicates can target sub-fields the GraphQL filter types omit,
-// such as address coordinates, the actor context or the phone country code
-const SUB_FIELD_MATCHERS_BY_COMPOSITE_TYPE: Partial<
- Record<FieldMetadataType, Record<string, SubFieldMatcher>>
-> = {
- [FieldMetadataType.FULL_NAME]: {
- firstName: matchString,
- lastName: matchString,
- },
- [FieldMetadataType.ADDRESS]: {
- addressStreet1: matchString,
- addressStreet2: matchString,
- addressCity: matchString,
- addressState: matchString,
- addressCountry: matchString,
- addressPostcode: matchString,
- addressLat: matchFloat,
- addressLng: matchFloat,
- },
- [FieldMetadataType.LINKS]: {
- primaryLinkLabel: matchString,
- primaryLinkUrl: matchString,
- secondaryLinks: matchRawJson,
- },
- [FieldMetadataType.ACTOR]: {
- source: matchSelect,
- name: matchString,
- workspaceMemberId: matchUuid,
- context: matchRawJson,
- },
- [FieldMetadataType.EMAILS]: {
- primaryEmail: matchString,
- additionalEmails: matchRawJson,
- },
- [FieldMetadataType.PHONES]: {
- primaryPhoneNumber: matchString,
- primaryPhoneCountryCode: matchString,
- primaryPhoneCallingCode: matchString,
- additionalPhones: matchRawJson,
- },
-};
-
-// Sub-fields are ANDed as in SQL. An absent or empty sub-field filter is no
-// constraint, one this matcher cannot read never matches, and a null
-// sub-field, of a null composite too, only matches IS NULL
-const isMatchingCompositeFilter = ({
- compositeFilter,
- compositeValue,
- subFieldMatchers,
-}: {
- compositeFilter: Record<string, { is?: IsFilter } | null | undefined>;
- compositeValue: Record<string, unknown> | null | undefined;
- subFieldMatchers: Record<string, SubFieldMatcher>;
-}): boolean =>
- Object.entries(compositeFilter).every(([subFieldName, subFieldFilter]) => {
- if (
- !isDefined(subFieldFilter) ||
- Object.keys(subFieldFilter).length === 0
- ) {
- return true;
- }
-
- const isMatching = subFieldMatchers[subFieldName];
-
- if (!isDefined(isMatching)) {
- return false;
- }
-
- const value = compositeValue?.[subFieldName];
-
- if (!isDefined(value)) {
- return subFieldFilter.is === 'NULL';
- }
-
- return isMatching(subFieldFilter, value);
- });
-
export const isRecordMatchingRLSRowLevelPermissionPredicate = ({
record,
filter,
@@ -327,7 +220,7 @@ export const isRecordMatchingRLSRowLevelPermissionPredicate = ({
}
const subFieldMatchers =
- SUB_FIELD_MATCHERS_BY_COMPOSITE_TYPE[objectMetadataField.type];
+ COMPOSITE_FIELD_SUB_FIELD_MATCHERS_MAP[objectMetadataField.type];
if (isDefined(subFieldMatchers)) {
return isMatchingCompositeFilter({
diff --git a/packages/twenty-shared/src/utils/filter/utils/__tests__/isMatchingCompositeFilter.test.ts b/packages/twenty-shared/src/utils/filter/utils/__tests__/isMatchingCompositeFilter.test.ts
new file mode 100644
index 00000000000..e4d6b8ecc35
--- /dev/null
+++ b/packages/twenty-shared/src/utils/filter/utils/__tests__/isMatchingCompositeFilter.test.ts
@@ -0,0 +1,94 @@
+import { FieldMetadataType } from '@/types';
+import { COMPOSITE_FIELD_SUB_FIELD_MATCHERS_MAP } from '@/utils/filter/utils/compositeFieldSubFieldMatchersMap';
+import { isMatchingCompositeFilter } from '@/utils/filter/utils/isMatchingCompositeFilter';
+
+const LINKS_MATCHERS =
+ COMPOSITE_FIELD_SUB_FIELD_MATCHERS_MAP[FieldMetadataType.LINKS] ?? {};
+
+const isMatchingLinksFilter = ({
+ compositeFilter,
+ compositeValue,
+}: {
+ compositeFilter: Record<string, object | undefined>;
+ compositeValue: Record<string, unknown> | null;
+}) =>
+ isMatchingCompositeFilter({
+ compositeFilter,
+ compositeValue,
+ subFieldMatchers: LINKS_MATCHERS,
+ });
+
+const LINKS_VALUE = {
+ primaryLinkUrl: 'https://twenty.com',
+ primaryLinkLabel: 'Twenty',
+ secondaryLinks: [{ url: 'https://docs.twenty.com', label: 'Docs' }],
+};
+
+describe('isMatchingCompositeFilter', () => {
+ it('matches when every sub-filter matches', () => {
+ expect(
+ isMatchingLinksFilter({
+ compositeFilter: {
+ primaryLinkUrl: { ilike: '%twenty%' },
+ primaryLinkLabel: { eq: 'Twenty' },
+ },
+ compositeValue: LINKS_VALUE,
+ }),
+ ).toBe(true);
+ });
+
+ it('does not match when one sub-filter fails', () => {
+ expect(
+ isMatchingLinksFilter({
+ compositeFilter: {
+ primaryLinkUrl: { ilike: '%twenty%' },
+ primaryLinkLabel: { eq: 'Other' },
+ },
+ compositeValue: LINKS_VALUE,
+ }),
+ ).toBe(false);
+ });
+
+ it('ignores absent and empty sub-filters', () => {
+ expect(
+ isMatchingLinksFilter({
+ compositeFilter: { primaryLinkUrl: {}, primaryLinkLabel: undefined },
+ compositeValue: LINKS_VALUE,
+ }),
+ ).toBe(true);
+ });
+
+ it('does not match a sub-field without a matcher', () => {
+ expect(
+ isMatchingLinksFilter({
+ compositeFilter: { unknownSubField: { eq: 'Twenty' } },
+ compositeValue: LINKS_VALUE,
+ }),
+ ).toBe(false);
+ });
+
+ it('matches a missing value only with IS NULL', () => {
+ expect(
+ isMatchingLinksFilter({
+ compositeFilter: { primaryLinkLabel: { is: 'NULL' } },
+ compositeValue: null,
+ }),
+ ).toBe(true);
+
+ expect(
+ isMatchingLinksFilter({
+ compositeFilter: { primaryLinkLabel: { eq: 'Twenty' } },
+ compositeValue: { primaryLinkLabel: null },
+ }),
+ ).toBe(false);
+ });
+
+ it('matches secondary links through their JSON content', () => {
+ expect(
+ isMatchingLinksFilter({
+ compositeFilter: { secondaryLinks: { like: '%docs.twenty.com%' } },
+ compositeValue: LINKS_VALUE,
+ }),
+ ).toBe(true);
+ });
+});
diff --git a/packages/twenty-shared/src/utils/filter/utils/compositeFieldSubFieldMatchersMap.ts b/packages/twenty-shared/src/utils/filter/utils/compositeFieldSubFieldMatchersMap.ts
new file mode 100644
index 00000000000..b78234087b0
--- /dev/null
+++ b/packages/twenty-shared/src/utils/filter/utils/compositeFieldSubFieldMatchersMap.ts
@@ -0,0 +1,99 @@
+import {
+ FieldMetadataType,
+ type FloatFilter,
+ type RawJsonFilter,
+ type SelectFilter,
+ type StringFilter,
+ type UUIDFilter,
+} from '@/types';
+import { type CompositeSubFieldMatcher } from '@/utils/filter/utils/isMatchingCompositeFilter';
+import { isMatchingFloatFilter } from '@/utils/filter/utils/isMatchingFloatFilter';
+import { isMatchingRawJsonFilter } from '@/utils/filter/utils/isMatchingRawJsonFilter';
+import { isMatchingSelectFilter } from '@/utils/filter/utils/isMatchingSelectFilter';
+import { isMatchingStringFilter } from '@/utils/filter/utils/isMatchingStringFilter';
+import { isMatchingUUIDFilter } from '@/utils/filter/utils/isMatchingUUIDFilter';
+
+const matchString: CompositeSubFieldMatcher = ({
+ subFieldFilter,
+ subFieldValue,
+}) =>
+ isMatchingStringFilter({
+ stringFilter: subFieldFilter as StringFilter,
+ value: subFieldValue as string,
+ });
+
+const matchRawJson: CompositeSubFieldMatcher = ({
+ subFieldFilter,
+ subFieldValue,
+}) =>
+ isMatchingRawJsonFilter({
+ rawJsonFilter: subFieldFilter as RawJsonFilter,
+ value: subFieldValue,
+ });
+
+const matchFloat: CompositeSubFieldMatcher = ({
+ subFieldFilter,
+ subFieldValue,
+}) =>
+ isMatchingFloatFilter({
+ floatFilter: subFieldFilter as FloatFilter,
+ value: subFieldValue as number,
+ });
+
+const matchSelect: CompositeSubFieldMatcher = ({
+ subFieldFilter,
+ subFieldValue,
+}) =>
+ isMatchingSelectFilter({
+ selectFilter: subFieldFilter as SelectFilter,
+ value: subFieldValue as string,
+ });
+
+const matchUuid: CompositeSubFieldMatcher = ({
+ subFieldFilter,
+ subFieldValue,
+}) =>
+ isMatchingUUIDFilter({
+ uuidFilter: subFieldFilter as UUIDFilter,
+ value: subFieldValue as string,
+ });
+
+export const COMPOSITE_FIELD_SUB_FIELD_MATCHERS_MAP: Partial<
+ Record<FieldMetadataType, Record<string, CompositeSubFieldMatcher>>
+> = {
+ [FieldMetadataType.FULL_NAME]: {
+ firstName: matchString,
+ lastName: matchString,
+ },
+ [FieldMetadataType.ADDRESS]: {
+ addressStreet1: matchString,
+ addressStreet2: matchString,
+ addressCity: matchString,
+ addressState: matchString,
+ addressCountry: matchString,
+ addressPostcode: matchString,
+ addressLat: matchFloat,
+ addressLng: matchFloat,
+ },
+ [FieldMetadataType.LINKS]: {
+ primaryLinkLabel: matchString,
+ primaryLinkUrl: matchString,
+ secondaryLinks: matchRawJson,
+ },
+ [FieldMetadataType.ACTOR]: {
+ source: matchSelect,
+ name: matchString,
+ workspaceMemberId: matchUuid,
+ context: matchRawJson,
+ },
+ [FieldMetadataType.EMAILS]: {
+ primaryEmail: matchString,
+ additionalEmails: matchRawJson,
+ },
+ [FieldMetadataType.PHONES]: {
+ primaryPhoneNumber: matchString,
+ primaryPhoneCountryCode: matchString,
+ primaryPhoneCallingCode: matchString,
+ additionalPhones: matchRawJson,
+ },
+};
diff --git a/packages/twenty-shared/src/utils/filter/utils/isMatchingCompositeFilter.ts b/packages/twenty-shared/src/utils/filter/utils/isMatchingCompositeFilter.ts
new file mode 100644
index 00000000000..fc1740cd84a
--- /dev/null
+++ b/packages/twenty-shared/src/utils/filter/utils/isMatchingCompositeFilter.ts
@@ -0,0 +1,42 @@
+import { type IsFilter } from '@/types';
+import { isDefined } from '@/utils/validation/isDefined';
+
+export type CompositeSubFieldMatcher = ({
+ subFieldFilter,
+ subFieldValue,
+}: {
+ subFieldFilter: object;
+ subFieldValue: unknown;
+}) => boolean;
+
+export const isMatchingCompositeFilter = ({
+ compositeFilter,
+ compositeValue,
+ subFieldMatchers,
+}: {
+ compositeFilter: Record<string, { is?: IsFilter } | null | undefined>;
+ compositeValue: Record<string, unknown> | null | undefined;
+ subFieldMatchers: Record<string, CompositeSubFieldMatcher>;
+}): boolean =>
+ Object.entries(compositeFilter).every(([subFieldName, subFieldFilter]) => {
+ if (
+ !isDefined(subFieldFilter) ||
+ Object.keys(subFieldFilter).length === 0
+ ) {
+ return true;
+ }
+
+ const isMatching = subFieldMatchers[subFieldName];
+
+ if (!isDefined(isMatching)) {
+ return false;
+ }
+
+ const subFieldValue = compositeValue?.[subFieldName];
+
+ if (!isDefined(subFieldValue)) {
+ return subFieldFilter.is === 'NULL';
+ }
+
+ return isMatching({ subFieldFilter, subFieldValue });
+ });
diff --git a/packages/twenty-shared/src/utils/index.ts b/packages/twenty-shared/src/utils/index.ts
index acb7327a7d6..046b5b9a34c 100644
--- a/packages/twenty-shared/src/utils/index.ts
+++ b/packages/twenty-shared/src/utils/index.ts
@@ -139,6 +139,7 @@ export { turnRecordFilterIntoRecordGqlOperationFilter } from './filter/turnRecor
export { combineFilters } from './filter/utils/combineFilters';
export { compareSelectOptionValues } from './filter/utils/compareSelectOptionValues';
export { COMPOSITE_FIELD_FILTER_OPERANDS_MAP } from './filter/utils/compositeFieldFilterOperandsMap';
+export { COMPOSITE_FIELD_SUB_FIELD_MATCHERS_MAP } from './filter/utils/compositeFieldSubFieldMatchersMap';
export { convertViewFilterOperandToCoreOperand } from './filter/utils/convert-view-filter-operand-to-core-operand.util';
export { convertLikePatternToRegexOrThrow } from './filter/utils/convertLikePatternToRegexOrThrow';
export { convertViewFilterValueToString } from './filter/utils/convertViewFilterValueToString';
@@ -157,6 +158,8 @@ export { getFilterTypeFromFieldType } from './filter/utils/getFilterTypeFromFiel
export { isExpectedSubFieldName } from './filter/utils/isExpectedSubFieldName';
export { isMatchingArrayFilter } from './filter/utils/isMatchingArrayFilter';
export { isMatchingBooleanFilter } from './filter/utils/isMatchingBooleanFilter';
+export type { CompositeSubFieldMatcher } from './filter/utils/isMatchingCompositeFilter';
+export { isMatchingCompositeFilter } from './filter/utils/isMatchingCompositeFilter';
export { isMatchingCurrencyFilter } from './filter/utils/isMatchingCurrencyFilter';
export { isMatchingDateFilter } from './filter/utils/isMatchingDateFilter';
export { isMatchingFilesFilter } from './filter/utils/isMatchingFilesFilter';