Skip to content

The open alternative to Salesforce, designed for AI.

Check every morph target join column in empty record filters (#28144)

Charles Bochet1b140e33833d
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/add-morph-relations-to-morph-relation-head-flat-field-metadatas.util.ts b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/add-morph-relations-to-morph-relation-head-flat-field-metadatas.util.ts
new file mode 100644
index 00000000000..d1f3b9e5b75
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/add-morph-relations-to-morph-relation-head-flat-field-metadatas.util.ts
@@ -0,0 +1,40 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+import { isMorphRelationHead } from 'twenty-shared/utils';
+
+import { type RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';
+import { resolveMorphRelationsFromFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/resolve-morph-relations-from-flat-field-metadata.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+export const addMorphRelationsToMorphRelationHeadFlatFieldMetadatas = ({
+ flatFieldMetadatas,
+ flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
+}: {
+ flatFieldMetadatas: FlatFieldMetadata[];
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+}): (FlatFieldMetadata & { morphRelations?: RelationDTO[] })[] => {
+ const resolveMorphRelations = (morphRelationHead: FlatFieldMetadata) =>
+ isFlatFieldMetadataOfType(
+ morphRelationHead,
+ FieldMetadataType.MORPH_RELATION,
+ )
+ ? resolveMorphRelationsFromFlatFieldMetadata({
+ morphFlatFieldMetadata: morphRelationHead,
+ flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
+ })
+ : [];
+
+ return flatFieldMetadatas.map((flatFieldMetadata) =>
+ isMorphRelationHead<FlatFieldMetadata>(flatFieldMetadata)
+ ? {
+ ...flatFieldMetadata,
+ morphRelations: resolveMorphRelations(flatFieldMetadata),
+ }
+ : flatFieldMetadata,
+ );
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/compute-flat-field-metadata-array-for-record-filters.util.ts b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/compute-flat-field-metadata-array-for-record-filters.util.ts
new file mode 100644
index 00000000000..43978561fb3
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/compute-flat-field-metadata-array-for-record-filters.util.ts
@@ -0,0 +1,34 @@
+import { isDefined, type RecordFilter } from 'twenty-shared/utils';
+
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+
+export const computeFlatFieldMetadataArrayForRecordFilters = ({
+ flatFieldMetadataMaps,
+ recordFilters,
+}: {
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ recordFilters: Pick<
+ RecordFilter,
+ 'fieldMetadataId' | 'relationTargetFieldMetadataId'
+ >[];
+}): FlatFieldMetadata[] => {
+ const recordFilterFieldMetadataIds = new Set(
+ recordFilters
+ .flatMap(({ fieldMetadataId, relationTargetFieldMetadataId }) => [
+ fieldMetadataId,
+ relationTargetFieldMetadataId,
+ ])
+ .filter(isDefined),
+ );
+
+ return [...recordFilterFieldMetadataIds]
+ .map((fieldMetadataId) =>
+ findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ }),
+ )
+ .filter(isDefined);
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/view/services/view-query-params.service.ts b/packages/twenty-server/src/engine/metadata-modules/view/services/view-query-params.service.ts
index 90ce8841394..54d8b399ac8 100644
--- a/packages/twenty-server/src/engine/metadata-modules/view/services/view-query-params.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/view/services/view-query-params.service.ts
@@ -20,6 +20,8 @@ import { type ObjectRecordOrderBy } from 'src/engine/api/graphql/workspace-query
import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
+import { addMorphRelationsToMorphRelationHeadFlatFieldMetadatas } from 'src/engine/metadata-modules/flat-field-metadata/utils/add-morph-relations-to-morph-relation-head-flat-field-metadatas.util';
+import { computeFlatFieldMetadataArrayForRecordFilters } from 'src/engine/metadata-modules/flat-field-metadata/utils/compute-flat-field-metadata-array-for-record-filters.util';
import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
import { DEFAULT_TIMEZONE } from 'src/engine/metadata-modules/view/constants/default-timezone.constant';
import {
@@ -130,9 +132,15 @@ export class ViewQueryParamsService {
}));
const filter = computeRecordGqlOperationFilter({
- fieldMetadataItems: Object.values(
- flatFieldMetadataMaps.byUniversalIdentifier,
- ).filter(isDefined),
+ fieldMetadataItems:
+ addMorphRelationsToMorphRelationHeadFlatFieldMetadatas({
+ flatFieldMetadatas: computeFlatFieldMetadataArrayForRecordFilters({
+ flatFieldMetadataMaps,
+ recordFilters: recordFilters,
+ }),
+ flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
+ }),
recordFilters,
recordFilterGroups,
filterValueDependencies: { currentWorkspaceMemberId, timeZone },
diff --git a/packages/twenty-server/src/modules/dashboard/chart-data/services/chart-data-query.service.ts b/packages/twenty-server/src/modules/dashboard/chart-data/services/chart-data-query.service.ts
index 2dee8d61e92..dff63b09451 100644
--- a/packages/twenty-server/src/modules/dashboard/chart-data/services/chart-data-query.service.ts
+++ b/packages/twenty-server/src/modules/dashboard/chart-data/services/chart-data-query.service.ts
@@ -99,6 +99,7 @@ export class ChartDataQueryService {
const gqlOperationFilter = convertChartFilterToGqlOperationFilter({
filter,
flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
userTimezone,
currentWorkspaceMemberId,
});
diff --git a/packages/twenty-server/src/modules/dashboard/chart-data/utils/__tests__/convert-chart-filter-to-gql-operation-filter.util.spec.ts b/packages/twenty-server/src/modules/dashboard/chart-data/utils/__tests__/convert-chart-filter-to-gql-operation-filter.util.spec.ts
index 91f1ec8c867..8cea0002157 100644
--- a/packages/twenty-server/src/modules/dashboard/chart-data/utils/__tests__/convert-chart-filter-to-gql-operation-filter.util.spec.ts
+++ b/packages/twenty-server/src/modules/dashboard/chart-data/utils/__tests__/convert-chart-filter-to-gql-operation-filter.util.spec.ts
@@ -1,11 +1,13 @@
import {
type ChartFilter,
FieldMetadataType,
+ RelationType,
ViewFilterOperand,
} from 'twenty-shared/types';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { convertChartFilterToGqlOperationFilter } from 'src/modules/dashboard/chart-data/utils/convert-chart-filter-to-gql-operation-filter.util';
const userTimezone = 'Europe/Paris';
@@ -19,21 +21,146 @@ const createdByFieldMetadata = {
relationTargetObjectMetadataId: 'workspace-member-object-id',
} as FlatFieldMetadata;
-const flatFieldMetadataMaps = {
- byUniversalIdentifier: {
- [createdByFieldMetadata.universalIdentifier]: createdByFieldMetadata,
+const OWNER_MORPH_ID = 'owner-morph-id';
+
+const buildOwnerFieldMetadata = ({
+ id,
+ name,
+ universalIdentifier,
+ relationTargetFieldMetadataId = null,
+ relationTargetObjectMetadataId = null,
+}: {
+ id: string;
+ name: string;
+ universalIdentifier: string;
+ relationTargetFieldMetadataId?: string | null;
+ relationTargetObjectMetadataId?: string | null;
+}) =>
+ ({
+ id,
+ name,
+ universalIdentifier,
+ type: FieldMetadataType.MORPH_RELATION,
+ morphId: OWNER_MORPH_ID,
+ objectMetadataId: 'pet-object-id',
+ relationTargetFieldMetadataId,
+ relationTargetObjectMetadataId,
+ settings: { relationType: RelationType.MANY_TO_ONE },
+ universalSettings: { relationType: RelationType.MANY_TO_ONE },
+ }) as unknown as FlatFieldMetadata;
+
+const ownerHeadFieldMetadata = buildOwnerFieldMetadata({
+ id: 'owner-head-field-id',
+ name: 'owner',
+ universalIdentifier: OWNER_MORPH_ID,
+});
+
+const ownerCompanyFieldMetadata = buildOwnerFieldMetadata({
+ id: 'owner-company-field-id',
+ name: 'ownerCompany',
+ universalIdentifier: 'owner-company-universal-id',
+ relationTargetFieldMetadataId: 'company-pets-field-id',
+ relationTargetObjectMetadataId: 'company-object-id',
+});
+
+const ownerPersonFieldMetadata = buildOwnerFieldMetadata({
+ id: 'owner-person-field-id',
+ name: 'ownerPerson',
+ universalIdentifier: 'owner-person-universal-id',
+ relationTargetFieldMetadataId: 'person-pets-field-id',
+ relationTargetObjectMetadataId: 'person-object-id',
+});
+
+const buildPetsFieldMetadata = ({
+ id,
+ objectMetadataId,
+}: {
+ id: string;
+ objectMetadataId: string;
+}) =>
+ ({
+ id,
+ name: 'pets',
+ universalIdentifier: `${id}-universal-id`,
+ type: FieldMetadataType.RELATION,
+ objectMetadataId,
+ relationTargetObjectMetadataId: 'pet-object-id',
+ settings: { relationType: RelationType.ONE_TO_MANY },
+ }) as unknown as FlatFieldMetadata;
+
+const toFlatEntityMaps = <
+ TFlatEntity extends { id: string; universalIdentifier: string },
+>(
+ flatEntities: TFlatEntity[],
+) => ({
+ byUniversalIdentifier: Object.fromEntries(
+ flatEntities.map((flatEntity) => [
+ flatEntity.universalIdentifier,
+ flatEntity,
+ ]),
+ ),
+ universalIdentifierById: Object.fromEntries(
+ flatEntities.map((flatEntity) => [
+ flatEntity.id,
+ flatEntity.universalIdentifier,
+ ]),
+ ),
+ universalIdentifiersByApplicationId: {},
+});
+
+const flatFieldMetadataMaps = toFlatEntityMaps([
+ createdByFieldMetadata,
+ ownerHeadFieldMetadata,
+ ownerCompanyFieldMetadata,
+ ownerPersonFieldMetadata,
+ buildPetsFieldMetadata({
+ id: 'company-pets-field-id',
+ objectMetadataId: 'company-object-id',
+ }),
+ buildPetsFieldMetadata({
+ id: 'person-pets-field-id',
+ objectMetadataId: 'person-object-id',
+ }),
+]) as unknown as FlatEntityMaps<FlatFieldMetadata>;
+
+const objectMetadatas = [
+ {
+ id: 'pet-object-id',
+ universalIdentifier: 'pet-universal-id',
+ nameSingular: 'pet',
+ namePlural: 'pets',
+ fieldIds: [
+ ownerHeadFieldMetadata.id,
+ ownerCompanyFieldMetadata.id,
+ ownerPersonFieldMetadata.id,
+ ],
},
- universalIdentifierById: {
- [createdByFieldMetadata.id]: createdByFieldMetadata.universalIdentifier,
+ {
+ id: 'company-object-id',
+ universalIdentifier: 'company-universal-id',
+ nameSingular: 'company',
+ namePlural: 'companies',
+ fieldIds: ['company-pets-field-id'],
},
- universalIdentifiersByApplicationId: {},
-} as unknown as FlatEntityMaps<FlatFieldMetadata>;
+ {
+ id: 'person-object-id',
+ universalIdentifier: 'person-universal-id',
+ nameSingular: 'person',
+ namePlural: 'people',
+ fieldIds: ['person-pets-field-id'],
+ },
+];
+
+const flatObjectMetadataMaps = toFlatEntityMaps(
+ objectMetadatas,
+) as unknown as FlatEntityMaps<FlatObjectMetadata>;
describe('convertChartFilterToGqlOperationFilter', () => {
it('returns an empty filter when no filter is provided', () => {
const result = convertChartFilterToGqlOperationFilter({
filter: undefined,
flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
userTimezone,
});
@@ -58,6 +185,7 @@ describe('convertChartFilterToGqlOperationFilter', () => {
const result = convertChartFilterToGqlOperationFilter({
filter,
flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
userTimezone,
currentWorkspaceMemberId,
});
@@ -87,9 +215,61 @@ describe('convertChartFilterToGqlOperationFilter', () => {
const result = convertChartFilterToGqlOperationFilter({
filter,
flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
userTimezone,
});
expect(result).toEqual({});
});
+
+ it('checks every target join column for an empty filter on a morph relation head', () => {
+ const filter: ChartFilter = {
+ recordFilters: [
+ {
+ fieldMetadataId: ownerHeadFieldMetadata.id,
+ operand: ViewFilterOperand.IS_NOT_EMPTY,
+ value: '',
+ type: FieldMetadataType.MORPH_RELATION,
+ },
+ ],
+ };
+
+ const result = convertChartFilterToGqlOperationFilter({
+ filter,
+ flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
+ userTimezone,
+ });
+
+ expect(result).toEqual({
+ not: {
+ and: [
+ { ownerCompanyId: { is: 'NULL' } },
+ { ownerPersonId: { is: 'NULL' } },
+ ],
+ },
+ });
+ });
+
+ it('checks the join column of a morph relation target for an empty filter on that target', () => {
+ const filter: ChartFilter = {
+ recordFilters: [
+ {
+ fieldMetadataId: ownerCompanyFieldMetadata.id,
+ operand: ViewFilterOperand.IS_EMPTY,
+ value: '',
+ type: FieldMetadataType.MORPH_RELATION,
+ },
+ ],
+ };
+
+ const result = convertChartFilterToGqlOperationFilter({
+ filter,
+ flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
+ userTimezone,
+ });
+
+ expect(result).toEqual({ ownerCompanyId: { is: 'NULL' } });
+ });
});
diff --git a/packages/twenty-server/src/modules/dashboard/chart-data/utils/convert-chart-filter-to-gql-operation-filter.util.ts b/packages/twenty-server/src/modules/dashboard/chart-data/utils/convert-chart-filter-to-gql-operation-filter.util.ts
index 8097024b639..0e021ddfb63 100644
--- a/packages/twenty-server/src/modules/dashboard/chart-data/utils/convert-chart-filter-to-gql-operation-filter.util.ts
+++ b/packages/twenty-server/src/modules/dashboard/chart-data/utils/convert-chart-filter-to-gql-operation-filter.util.ts
@@ -17,10 +17,14 @@ import { type ObjectRecordFilter } from 'src/engine/api/graphql/workspace-query-
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { addMorphRelationsToMorphRelationHeadFlatFieldMetadatas } from 'src/engine/metadata-modules/flat-field-metadata/utils/add-morph-relations-to-morph-relation-head-flat-field-metadatas.util';
+import { computeFlatFieldMetadataArrayForRecordFilters } from 'src/engine/metadata-modules/flat-field-metadata/utils/compute-flat-field-metadata-array-for-record-filters.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
type ConvertChartFilterToGqlOperationFilterParams = {
filter: ChartFilter | undefined;
flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
userTimezone: string;
currentWorkspaceMemberId?: string;
};
@@ -28,6 +32,7 @@ type ConvertChartFilterToGqlOperationFilterParams = {
export const convertChartFilterToGqlOperationFilter = ({
filter,
flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
userTimezone,
currentWorkspaceMemberId,
}: ConvertChartFilterToGqlOperationFilterParams): ObjectRecordFilter => {
@@ -76,9 +81,14 @@ export const convertChartFilterToGqlOperationFilter = ({
}));
return computeRecordGqlOperationFilter({
- fieldMetadataItems: Object.values(
- flatFieldMetadataMaps.byUniversalIdentifier,
- ).filter(isDefined),
+ fieldMetadataItems: addMorphRelationsToMorphRelationHeadFlatFieldMetadatas({
+ flatFieldMetadatas: computeFlatFieldMetadataArrayForRecordFilters({
+ flatFieldMetadataMaps,
+ recordFilters: convertedRecordFilters,
+ }),
+ flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
+ }),
recordFilters: convertedRecordFilters,
recordFilterGroups: convertedRecordFilterGroups,
filterValueDependencies: {
diff --git a/packages/twenty-shared/src/utils/filter/computeEmptyGqlOperationFilterForMorphRelation.ts b/packages/twenty-shared/src/utils/filter/computeEmptyGqlOperationFilterForMorphRelation.ts
new file mode 100644
index 00000000000..ea92caf6179
--- /dev/null
+++ b/packages/twenty-shared/src/utils/filter/computeEmptyGqlOperationFilterForMorphRelation.ts
@@ -0,0 +1,34 @@
+import {
+ type PartialFieldMetadataItem,
+ type RecordGqlOperationFilter,
+ type RelationFilter,
+} from '@/types';
+import { isNonEmptyArray } from '@/utils/array/isNonEmptyArray';
+import { computeMorphRelationGqlFieldJoinColumnName } from '@/utils/fieldMetadata/compute-relation-gql-field-join-column-name';
+import { type FieldShared } from '@/utils/filter/turnRecordFilterIntoGqlOperationFilter';
+
+export const computeEmptyGqlOperationFilterForMorphRelation = ({
+ correspondingFieldMetadataItem,
+}: {
+ correspondingFieldMetadataItem: Pick<PartialFieldMetadataItem, 'name'> &
+ Pick<FieldShared, 'morphRelations'>;
+}): RecordGqlOperationFilter => {
+ const { name, morphRelations } = correspondingFieldMetadataItem;
+
+ if (!isNonEmptyArray(morphRelations)) {
+ return { [`${name}Id`]: { is: 'NULL' } satisfies RelationFilter };
+ }
+
+ return {
+ and: morphRelations.map((morphRelation) => ({
+ [computeMorphRelationGqlFieldJoinColumnName({
+ fieldName: name,
+ relationType: morphRelation.type,
+ targetObjectMetadataNameSingular:
+ morphRelation.targetObjectMetadata.nameSingular,
+ targetObjectMetadataNamePlural:
+ morphRelation.targetObjectMetadata.namePlural,
+ })]: { is: 'NULL' } satisfies RelationFilter,
+ })),
+ };
+};
diff --git a/packages/twenty-shared/src/utils/filter/utils/__tests__/getEmptyRecordGqlOperationFilter.test.ts b/packages/twenty-shared/src/utils/filter/utils/__tests__/getEmptyRecordGqlOperationFilter.test.ts
index 4fe8f97084d..86b2c45ccaf 100644
--- a/packages/twenty-shared/src/utils/filter/utils/__tests__/getEmptyRecordGqlOperationFilter.test.ts
+++ b/packages/twenty-shared/src/utils/filter/utils/__tests__/getEmptyRecordGqlOperationFilter.test.ts
@@ -1,4 +1,4 @@
-import { FieldMetadataType, ViewFilterOperand } from '@/types';
+import { FieldMetadataType, RelationType, ViewFilterOperand } from '@/types';
import { getEmptyRecordGqlOperationFilter } from '@/utils/filter/utils/getEmptyRecordGqlOperationFilter';
import { type RecordFilter } from '@/utils';
@@ -19,6 +19,30 @@ const makeParams = (
} as RecordFilter,
});
+const MORPH_RELATION_FIELD = {
+ id: 'f1',
+ name: 'owner',
+ type: FieldMetadataType.MORPH_RELATION,
+ morphRelations: [
+ {
+ type: RelationType.MANY_TO_ONE,
+ targetObjectMetadata: {
+ id: 'company-id',
+ nameSingular: 'company',
+ namePlural: 'companies',
+ },
+ },
+ {
+ type: RelationType.MANY_TO_ONE,
+ targetObjectMetadata: {
+ id: 'person-id',
+ nameSingular: 'person',
+ namePlural: 'people',
+ },
+ },
+ ],
+};
+
describe('getEmptyRecordGqlOperationFilter', () => {
describe('IS_EMPTY operand', () => {
it('should handle TEXT type', () => {
@@ -97,6 +121,30 @@ describe('getEmptyRecordGqlOperationFilter', () => {
});
});
+ it('should check every target join column for MORPH_RELATION type', () => {
+ const result = getEmptyRecordGqlOperationFilter({
+ ...makeParams(FieldMetadataType.MORPH_RELATION),
+ correspondingField: MORPH_RELATION_FIELD,
+ });
+
+ expect(result).toEqual({
+ and: [
+ { ownerCompanyId: { is: 'NULL' } },
+ { ownerPersonId: { is: 'NULL' } },
+ ],
+ });
+ });
+
+ it('should check its own join column for a MORPH_RELATION target without morph relations', () => {
+ const result = getEmptyRecordGqlOperationFilter(
+ makeParams(FieldMetadataType.MORPH_RELATION),
+ );
+
+ expect(result).toEqual({
+ testFieldId: { is: 'NULL' },
+ });
+ });
+
it('should handle UUID type', () => {
const result = getEmptyRecordGqlOperationFilter(
makeParams(FieldMetadataType.UUID),
@@ -274,6 +322,25 @@ describe('getEmptyRecordGqlOperationFilter', () => {
expect(result).toHaveProperty('not');
});
+ it('should match a record with any target set for MORPH_RELATION type', () => {
+ const result = getEmptyRecordGqlOperationFilter({
+ ...makeParams(
+ FieldMetadataType.MORPH_RELATION,
+ ViewFilterOperand.IS_NOT_EMPTY,
+ ),
+ correspondingField: MORPH_RELATION_FIELD,
+ });
+
+ expect(result).toEqual({
+ not: {
+ and: [
+ { ownerCompanyId: { is: 'NULL' } },
+ { ownerPersonId: { is: 'NULL' } },
+ ],
+ },
+ });
+ });
+
it('should negate the currencyCode check for the CURRENCY currencyCode sub-field', () => {
const result = getEmptyRecordGqlOperationFilter(
makeParams(
diff --git a/packages/twenty-shared/src/utils/filter/utils/getEmptyRecordGqlOperationFilter.ts b/packages/twenty-shared/src/utils/filter/utils/getEmptyRecordGqlOperationFilter.ts
index d8c78821253..02b99574604 100644
--- a/packages/twenty-shared/src/utils/filter/utils/getEmptyRecordGqlOperationFilter.ts
+++ b/packages/twenty-shared/src/utils/filter/utils/getEmptyRecordGqlOperationFilter.ts
@@ -1,4 +1,5 @@
import {
+ FieldMetadataType,
ViewFilterOperand,
type ActorFilter,
type AddressFilter,
@@ -20,14 +21,17 @@ import {
import { CustomError } from '@/utils/errors';
import { computeEmptyGqlOperationFilterForEmails } from '@/utils/filter/computeEmptyGqlOperationFilterForEmails';
import { computeEmptyGqlOperationFilterForLinks } from '@/utils/filter/computeEmptyGqlOperationFilterForLinks';
+import { computeEmptyGqlOperationFilterForMorphRelation } from '@/utils/filter/computeEmptyGqlOperationFilterForMorphRelation';
import { type RecordFilter } from '@/utils/filter/turnRecordFilterGroupIntoGqlOperationFilter';
+import { type FieldShared } from '@/utils/filter/turnRecordFilterIntoGqlOperationFilter';
import { generateILikeFiltersForCompositeFields } from '@/utils/filter/utils/generateILikeFiltersForCompositeFields';
import { getFilterTypeFromFieldType } from '@/utils/filter/utils/getFilterTypeFromFieldType';
import { isNonEmptyString } from '@sniptt/guards';
type GetEmptyRecordGqlOperationFilterParams = {
operand: ViewFilterOperand;
- correspondingField: Pick<PartialFieldMetadataItem, 'id' | 'name' | 'type'>;
+ correspondingField: Pick<PartialFieldMetadataItem, 'id' | 'name' | 'type'> &
+ Pick<FieldShared, 'morphRelations'>;
recordFilter: Omit<RecordFilter, 'id'>;
};
@@ -330,9 +334,16 @@ export const getEmptyRecordGqlOperationFilter = ({
};
break;
case 'RELATION':
- emptyRecordFilter = {
- [correspondingField.name + 'Id']: { is: 'NULL' } as RelationFilter,
- };
+ emptyRecordFilter =
+ correspondingField.type === FieldMetadataType.MORPH_RELATION
+ ? computeEmptyGqlOperationFilterForMorphRelation({
+ correspondingFieldMetadataItem: correspondingField,
+ })
+ : {
+ [correspondingField.name + 'Id']: {
+ is: 'NULL',
+ } as RelationFilter,
+ };
break;
case 'ACTOR':
emptyRecordFilter = {
diff --git a/packages/twenty-shared/src/utils/index.ts b/packages/twenty-shared/src/utils/index.ts
index a5efa60ed28..c1de1f1222a 100644
--- a/packages/twenty-shared/src/utils/index.ts
+++ b/packages/twenty-shared/src/utils/index.ts
@@ -88,6 +88,7 @@ export { computeGqlOperationFilterForEmails } from './filter/compute-record-gql-
export { computeGqlOperationFilterForLinks } from './filter/compute-record-gql-operation-filter/for-composite-field/computeGqlOperationFilterForLinks';
export { computeEmptyGqlOperationFilterForEmails } from './filter/computeEmptyGqlOperationFilterForEmails';
export { computeEmptyGqlOperationFilterForLinks } from './filter/computeEmptyGqlOperationFilterForLinks';
+export { computeEmptyGqlOperationFilterForMorphRelation } from './filter/computeEmptyGqlOperationFilterForMorphRelation';
export { computeRecordGqlOperationFilter } from './filter/computeRecordGqlOperationFilter';
export type { DateTimePeriod } from './filter/dates/types/DateTimePeriod';
export { addUnitToDateTime } from './filter/dates/utils/addUnitToDateTime';