Skip to content

The open alternative to Salesforce, designed for AI.

3.3 KB
Raw Blame
import { type ApolloCache, type StoreObject } from '@apollo/client';

import { triggerUpdateRootQueriesOptimisticEffect } from '@/apollo/optimistic-effect/utils/triggerUpdateRootQueriesOptimisticEffect';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { getRecordFromCache } from '@/object-record/cache/utils/getRecordFromCache';
import { getRecordNodeFromRecord } from '@/object-record/cache/utils/getRecordNodeFromRecord';
import { isObjectRecordConnectionWithRefs } from '@/object-record/cache/utils/isObjectRecordConnectionWithRefs';
import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
import { type ObjectPermissions } from 'twenty-shared/types';
import { capitalize, isDefined } from 'twenty-shared/utils';

export const triggerDetachRelationOptimisticEffect = ({
  cache,
  sourceObjectNameSingular,
  sourceRecordId,
  targetObjectMetadataItem,
  fieldNameOnTargetRecord,
  targetRecordId,
  objectMetadataItems,
  objectPermissionsByObjectMetadataId,
  upsertRecordsInStore,
}: {
  cache: ApolloCache;
  sourceObjectNameSingular: string;
  sourceRecordId: string;
  targetObjectMetadataItem: EnrichedObjectMetadataItem;
  fieldNameOnTargetRecord: string;
  targetRecordId: string;
  objectMetadataItems: EnrichedObjectMetadataItem[];
  objectPermissionsByObjectMetadataId: Record<
    string,
    ObjectPermissions & { objectMetadataId: string }
  >;
  upsertRecordsInStore: (props: { partialRecords: ObjectRecord[] }) => void;
}) => {
  const targetRecordTypeName = capitalize(
    targetObjectMetadataItem.nameSingular,
  );

  const targetRecordCacheId = cache.identify({
    id: targetRecordId,
    __typename: targetRecordTypeName,
  });

  cache.modify<StoreObject>({
    id: targetRecordCacheId,
    fields: {
      [fieldNameOnTargetRecord]: (
        targetRecordFieldValue,
        { isReference, readField },
      ) => {
        const isRecordConnection = isObjectRecordConnectionWithRefs(
          sourceObjectNameSingular,
          targetRecordFieldValue,
        );

        if (isRecordConnection) {
          const nextEdges = targetRecordFieldValue.edges.filter(
            ({ node }) => readField('id', node) !== sourceRecordId,
          );

          return {
            ...targetRecordFieldValue,
            edges: nextEdges,
          };
        }

        const isSingleReference = isReference(targetRecordFieldValue);

        if (isSingleReference) {
          return null;
        }

        return targetRecordFieldValue;
      },
    },
  });

  const newCachedRecord = getRecordFromCache({
    cache,
    objectMetadataItem: targetObjectMetadataItem,
    objectMetadataItems,
    recordId: targetRecordId,
    objectPermissionsByObjectMetadataId,
  });

  if (!isDefined(newCachedRecord)) {
    return;
  }

  upsertRecordsInStore({ partialRecords: [newCachedRecord] });

  const newCachedRecordNode = getRecordNodeFromRecord({
    objectMetadataItems,
    objectMetadataItem: targetObjectMetadataItem,
    record: newCachedRecord,
    computeReferences: false,
  });

  if (!isDefined(newCachedRecordNode)) {
    return;
  }

  triggerUpdateRootQueriesOptimisticEffect({
    cache,
    objectMetadataItem: targetObjectMetadataItem,
    objectMetadataItems,
    updatedRecords: [newCachedRecordNode],
  });
};