The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
import { triggerAttachRelationOptimisticEffect } from '@/apollo/optimistic-effect/utils/triggerAttachRelationOptimisticEffect';
import { triggerDestroyRecordsOptimisticEffect } from '@/apollo/optimistic-effect/utils/triggerDestroyRecordsOptimisticEffect';
import { triggerDetachRelationOptimisticEffect } from '@/apollo/optimistic-effect/utils/triggerDetachRelationOptimisticEffect';
import {
CoreObjectNameSingular,
FieldMetadataType,
RelationType,
type ObjectPermissions,
} from 'twenty-shared/types';
import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
import { type FieldMetadataItemRelation } from '@/object-metadata/types/FieldMetadataItemRelation';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { getFieldMetadataItemById } from '@/object-metadata/utils/getFieldMetadataItemById';
import { type RecordGqlConnectionEdgesRequired } from '@/object-record/graphql/types/RecordGqlConnectionEdgesRequired';
import { type RecordGqlNode } from '@/object-record/graphql/types/RecordGqlNode';
import { isFieldMorphRelation } from '@/object-record/record-field/ui/types/guards/isFieldMorphRelation';
import { isFieldRelation } from '@/object-record/record-field/ui/types/guards/isFieldRelation';
import { getJunctionObjectMetadataIds } from '@/object-record/record-field/ui/utils/junction/getJunctionObjectMetadataIds';
import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
import { type ApolloCache } from '@apollo/client';
import { isArray } from '@sniptt/guards';
import {
computeMorphRelationGqlFieldName,
CustomError,
isDefined,
} from 'twenty-shared/utils';
import { doNotTranslate } from 'twenty-shared/i18n';
import { isDeeplyEqual } from '~/utils/isDeeplyEqual';
type TriggerUpdateRelationsOptimisticEffectArgs = {
cache: ApolloCache;
sourceObjectMetadataItem: EnrichedObjectMetadataItem;
currentSourceRecord: RecordGqlNode | null;
updatedSourceRecord: RecordGqlNode | null;
objectMetadataItems: EnrichedObjectMetadataItem[];
objectPermissionsByObjectMetadataId: Record<
string,
ObjectPermissions & { objectMetadataId: string }
>;
upsertRecordsInStore: (props: { partialRecords: ObjectRecord[] }) => void;
};
// A junction only links its two sides, so detaching destroys it; comments are the one non-junction cascade.
const shouldCascadeDeleteOnDetach = ({
targetObjectMetadata,
junctionObjectMetadataIds,
}: {
targetObjectMetadata: FieldMetadataItemRelation['targetObjectMetadata'];
junctionObjectMetadataIds: ReadonlySet<string>;
}) =>
junctionObjectMetadataIds.has(targetObjectMetadata.id) ||
targetObjectMetadata.nameSingular === CoreObjectNameSingular.Comment;
export const triggerUpdateRelationsOptimisticEffect = ({
cache,
sourceObjectMetadataItem,
currentSourceRecord,
updatedSourceRecord,
objectMetadataItems,
objectPermissionsByObjectMetadataId,
upsertRecordsInStore,
}: TriggerUpdateRelationsOptimisticEffectArgs) => {
const isDeletion =
isDefined(updatedSourceRecord) &&
isDefined(updatedSourceRecord['deletedAt']);
const junctionObjectMetadataIds =
getJunctionObjectMetadataIds(objectMetadataItems);
sourceObjectMetadataItem.fields.forEach((fieldMetadataItemOnSourceRecord) => {
if (
!isFieldMorphRelation(fieldMetadataItemOnSourceRecord) &&
!isFieldRelation(fieldMetadataItemOnSourceRecord)
) {
return;
}
if (isFieldRelation(fieldMetadataItemOnSourceRecord)) {
triggerUpdateRelationOptimisticEffect({
fieldMetadataItemOnSourceRecord,
updatedSourceRecord,
currentSourceRecord,
objectMetadataItems,
sourceObjectMetadataItem,
cache,
isDeletion,
upsertRecordsInStore,
objectPermissionsByObjectMetadataId,
junctionObjectMetadataIds,
});
}
if (isFieldMorphRelation(fieldMetadataItemOnSourceRecord)) {
triggerUpdateMorphRelationOptimisticEffect({
fieldMetadataItemOnSourceRecord,
updatedSourceRecord,
currentSourceRecord,
objectMetadataItems,
sourceObjectMetadataItem,
cache,
isDeletion,
upsertRecordsInStore,
objectPermissionsByObjectMetadataId,
junctionObjectMetadataIds,
});
}
});
};
const triggerUpdateRelationOptimisticEffect = ({
fieldMetadataItemOnSourceRecord,
updatedSourceRecord,
currentSourceRecord,
objectMetadataItems,
sourceObjectMetadataItem,
cache,
isDeletion,
upsertRecordsInStore,
objectPermissionsByObjectMetadataId,
junctionObjectMetadataIds,
}: {
fieldMetadataItemOnSourceRecord: FieldMetadataItem;
updatedSourceRecord: RecordGqlNode | null;
currentSourceRecord: RecordGqlNode | null;
objectMetadataItems: EnrichedObjectMetadataItem[];
sourceObjectMetadataItem: EnrichedObjectMetadataItem;
cache: ApolloCache;
isDeletion: boolean;
upsertRecordsInStore: (props: { partialRecords: ObjectRecord[] }) => void;
objectPermissionsByObjectMetadataId: Record<
string,
ObjectPermissions & { objectMetadataId: string }
>;
junctionObjectMetadataIds: ReadonlySet<string>;
}) => {
const fieldDoesNotExist =
isDefined(updatedSourceRecord) &&
!(fieldMetadataItemOnSourceRecord.name in updatedSourceRecord);
if (fieldDoesNotExist) {
return;
}
const relation = fieldMetadataItemOnSourceRecord.relation;
if (!relation) {
return;
}
const { targetObjectMetadata, targetFieldMetadata } = relation;
const { fieldMetadataItem: targetFieldMetadataFullObject } =
getFieldMetadataItemById({
fieldMetadataId: targetFieldMetadata.id,
objectMetadataItems,
});
if (!targetFieldMetadataFullObject) {
throw new CustomError(
doNotTranslate('Target field metadata full object not found'),
'TARGET_FIELD_METADATA_FULL_OBJECT_NOT_FOUND',
);
}
const fullTargetObjectMetadataItem = objectMetadataItems.find(
({ nameSingular }) => nameSingular === targetObjectMetadata.nameSingular,
);
if (!fullTargetObjectMetadataItem) {
return;
}
const currentFieldValueOnSourceRecord:
| RecordGqlConnectionEdgesRequired
| RecordGqlNode
| null = currentSourceRecord?.[fieldMetadataItemOnSourceRecord.name];
const updatedFieldValueOnSourceRecord:
| RecordGqlConnectionEdgesRequired
| RecordGqlNode
| null = updatedSourceRecord?.[fieldMetadataItemOnSourceRecord.name];
const noDiff = isDeeplyEqual(
currentFieldValueOnSourceRecord,
updatedFieldValueOnSourceRecord,
{ strict: true },
);
if (noDiff && !isDeletion) {
return;
}
const recordToExtractDetachFrom = isDeletion
? updatedFieldValueOnSourceRecord
: currentFieldValueOnSourceRecord;
const targetRecordsToDetachFrom = extractTargetRecordsFromRelation(
recordToExtractDetachFrom,
relation,
);
const shouldCascadeDeleteTargetRecords = shouldCascadeDeleteOnDetach({
targetObjectMetadata,
junctionObjectMetadataIds,
});
const gqlFieldNameOnTargetRecord =
targetFieldMetadataFullObject.type === FieldMetadataType.RELATION
? targetFieldMetadataFullObject.name
: computeMorphRelationGqlFieldName({
fieldName: targetFieldMetadataFullObject.name,
relationType: targetFieldMetadataFullObject.settings?.relationType,
targetObjectMetadataNameSingular:
sourceObjectMetadataItem.nameSingular,
targetObjectMetadataNamePlural: sourceObjectMetadataItem.namePlural,
});
if (
shouldCascadeDeleteTargetRecords &&
targetRecordsToDetachFrom.length > 0
) {
triggerDestroyRecordsOptimisticEffect({
cache,
objectMetadataItem: fullTargetObjectMetadataItem,
recordsToDestroy: targetRecordsToDetachFrom,
objectMetadataItems,
upsertRecordsInStore,
objectPermissionsByObjectMetadataId,
});
} else if (
isDefined(currentSourceRecord) &&
targetRecordsToDetachFrom.length > 0
) {
targetRecordsToDetachFrom.forEach((targetRecordToDetachFrom) => {
triggerDetachRelationOptimisticEffect({
cache,
sourceObjectNameSingular: sourceObjectMetadataItem.nameSingular,
sourceRecordId: currentSourceRecord.id,
fieldNameOnTargetRecord: gqlFieldNameOnTargetRecord,
targetObjectMetadataItem: fullTargetObjectMetadataItem,
targetRecordId: targetRecordToDetachFrom.id,
objectMetadataItems,
objectPermissionsByObjectMetadataId,
upsertRecordsInStore,
});
});
}
if (!isDeletion && isDefined(updatedSourceRecord)) {
const targetRecordsToAttachTo = extractTargetRecordsFromRelation(
updatedFieldValueOnSourceRecord,
relation,
);
targetRecordsToAttachTo.forEach((targetRecordToAttachTo) =>
triggerAttachRelationOptimisticEffect({
cache,
sourceObjectNameSingular: sourceObjectMetadataItem.nameSingular,
sourceRecord: updatedSourceRecord,
fieldNameOnTargetRecord: gqlFieldNameOnTargetRecord,
targetObjectMetadataItem: fullTargetObjectMetadataItem,
targetRecordId: targetRecordToAttachTo.id,
objectMetadataItems,
objectPermissionsByObjectMetadataId,
upsertRecordsInStore,
}),
);
}
};
const triggerUpdateMorphRelationOptimisticEffect = ({
fieldMetadataItemOnSourceRecord,
updatedSourceRecord,
currentSourceRecord,
objectMetadataItems,
sourceObjectMetadataItem,
cache,
isDeletion,
objectPermissionsByObjectMetadataId,
upsertRecordsInStore,
junctionObjectMetadataIds,
}: {
fieldMetadataItemOnSourceRecord: FieldMetadataItem;
updatedSourceRecord: RecordGqlNode | null;
currentSourceRecord: RecordGqlNode | null;
objectMetadataItems: EnrichedObjectMetadataItem[];
sourceObjectMetadataItem: EnrichedObjectMetadataItem;
cache: ApolloCache;
isDeletion: boolean;
upsertRecordsInStore: (props: { partialRecords: ObjectRecord[] }) => void;
objectPermissionsByObjectMetadataId: Record<
string,
ObjectPermissions & { objectMetadataId: string }
>;
junctionObjectMetadataIds: ReadonlySet<string>;
}) => {
const morphRelations = fieldMetadataItemOnSourceRecord.morphRelations;
if (!morphRelations) {
return;
}
morphRelations.forEach((morphRelation) => {
const gqlFieldMorphRelation = computeMorphRelationGqlFieldName({
fieldName: fieldMetadataItemOnSourceRecord.name,
relationType: morphRelation.type,
targetObjectMetadataNameSingular:
morphRelation.targetObjectMetadata.nameSingular,
targetObjectMetadataNamePlural:
morphRelation.targetObjectMetadata.namePlural,
});
const { fieldMetadataItem: targetFieldMetadataFullObject } =
getFieldMetadataItemById({
fieldMetadataId: morphRelation.targetFieldMetadata.id,
objectMetadataItems,
});
if (!targetFieldMetadataFullObject) {
throw new CustomError(
doNotTranslate('Target field metadata full object not found'),
'TARGET_FIELD_METADATA_FULL_OBJECT_NOT_FOUND',
);
}
const fieldDoesNotExist =
isDefined(updatedSourceRecord) &&
!(gqlFieldMorphRelation in updatedSourceRecord);
if (fieldDoesNotExist) {
return;
}
const { targetObjectMetadata, targetFieldMetadata } = morphRelation;
const fullTargetObjectMetadataItem = objectMetadataItems.find(
({ nameSingular }) => nameSingular === targetObjectMetadata.nameSingular,
);
if (!fullTargetObjectMetadataItem) {
return;
}
const currentFieldValueOnSourceRecord:
| RecordGqlConnectionEdgesRequired
| RecordGqlNode
| null = currentSourceRecord?.[gqlFieldMorphRelation];
const updatedFieldValueOnSourceRecord:
| RecordGqlConnectionEdgesRequired
| RecordGqlNode
| null = updatedSourceRecord?.[gqlFieldMorphRelation];
const noDiff = isDeeplyEqual(
currentFieldValueOnSourceRecord,
updatedFieldValueOnSourceRecord,
{ strict: true },
);
if (noDiff && !isDeletion) {
return;
}
const recordToExtractDetachFrom = isDeletion
? updatedFieldValueOnSourceRecord
: currentFieldValueOnSourceRecord;
const targetRecordsToDetachFrom = extractTargetRecordsFromRelation(
recordToExtractDetachFrom,
morphRelation,
);
const shouldCascadeDeleteTargetRecords = shouldCascadeDeleteOnDetach({
targetObjectMetadata,
junctionObjectMetadataIds,
});
if (
shouldCascadeDeleteTargetRecords &&
targetRecordsToDetachFrom.length > 0
) {
triggerDestroyRecordsOptimisticEffect({
cache,
objectMetadataItem: fullTargetObjectMetadataItem,
recordsToDestroy: targetRecordsToDetachFrom,
objectMetadataItems,
objectPermissionsByObjectMetadataId,
upsertRecordsInStore,
});
} else if (
isDefined(currentSourceRecord) &&
targetRecordsToDetachFrom.length > 0
) {
targetRecordsToDetachFrom.forEach((targetRecordToDetachFrom) => {
triggerDetachRelationOptimisticEffect({
cache,
sourceObjectNameSingular: sourceObjectMetadataItem.nameSingular,
sourceRecordId: currentSourceRecord.id,
fieldNameOnTargetRecord: targetFieldMetadata.name,
targetObjectMetadataItem: fullTargetObjectMetadataItem,
objectMetadataItems,
objectPermissionsByObjectMetadataId,
targetRecordId: targetRecordToDetachFrom.id,
upsertRecordsInStore,
});
});
}
if (!isDeletion && isDefined(updatedSourceRecord)) {
const targetRecordsToAttachTo = extractTargetRecordsFromRelation(
updatedFieldValueOnSourceRecord,
morphRelation,
);
targetRecordsToAttachTo.forEach((targetRecordToAttachTo) =>
triggerAttachRelationOptimisticEffect({
cache,
sourceObjectNameSingular: sourceObjectMetadataItem.nameSingular,
sourceRecord: updatedSourceRecord,
fieldNameOnTargetRecord: targetFieldMetadata.name,
targetObjectMetadataItem: fullTargetObjectMetadataItem,
objectMetadataItems,
objectPermissionsByObjectMetadataId,
targetRecordId: targetRecordToAttachTo.id,
upsertRecordsInStore,
}),
);
}
});
};
const extractTargetRecordsFromRelation = (
value: RecordGqlConnectionEdgesRequired | RecordGqlNode | null,
relation: FieldMetadataItemRelation,
): RecordGqlNode[] => {
// TODO: find why arrays get injected here; ObjectRecord/RecordGqlNode mixing may corrupt the cache.
if (!isDefined(value) || isArray(value)) {
return [];
}
if (!isDefined(relation)) {
throw new Error(doNotTranslate('Relation found is undefined'));
}
if (relation.type === RelationType.ONE_TO_MANY) {
return value.edges.map(({ node }: { node: RecordGqlNode }) => node);
}
return [value as RecordGqlNode];
};