Skip to content

The open alternative to Salesforce, designed for AI.

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

import { normalizeGroupByDimensionValue } from '@/apollo/optimistic-effect/group-by/utils/normalizeGroupByDimensionValue';
import { processGroupByConnectionWithRecords } from '@/apollo/optimistic-effect/group-by/utils/processGroupByConnectionWithRecords';
import { type CachedObjectRecordQueryVariables } from '@/apollo/types/CachedObjectRecordQueryVariables';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { type RecordGqlRefEdge } from '@/object-record/cache/types/RecordGqlRefEdge';
import { createCacheEdgeWithRecordRef } from '@/object-record/cache/utils/createCacheEdgeWithRecordRef';
import { type RecordGqlNode } from '@/object-record/graphql/types/RecordGqlNode';
import { type RecordGqlGroupByConnection } from '@/object-record/graphql/types/RecordGqlOperationGroupByResult';
import { type RecordGqlOperationGroupByVariables } from '@/object-record/graphql/types/RecordGqlOperationGroupByVariables';
import { isRecordMatchingFilter } from '@/object-record/record-filter/utils/isRecordMatchingFilter';
import { isArray } from '@sniptt/guards';
import { getGroupByConnectionTypename, isDefined } from 'twenty-shared/utils';
import { parseApolloStoreFieldName } from '~/utils/parseApolloStoreFieldName';

type TriggerUpdateGroupByQueriesOptimisticEffectArgs = {
  cache: ApolloCache;
  objectMetadataItem: EnrichedObjectMetadataItem;
  objectMetadataItems: EnrichedObjectMetadataItem[];
  operation: 'create' | 'update' | 'delete';
  records: RecordGqlNode[];
  shouldMatchRootQueryFilter?: boolean;
};

export const triggerUpdateGroupByQueriesOptimisticEffect = ({
  cache,
  objectMetadataItem,
  objectMetadataItems,
  operation,
  records,
  shouldMatchRootQueryFilter = false,
}: TriggerUpdateGroupByQueriesOptimisticEffectArgs) => {
  const groupByQueryFieldName = `${objectMetadataItem.namePlural}GroupBy`;

  cache.modify<StoreObject>({
    broadcast: false,
    fields: {
      [groupByQueryFieldName]: (
        cachedGroupByQueryResult,
        { readField, toReference, storeFieldName },
      ) => {
        const cachedGroupByConnections = cachedGroupByQueryResult as
          | RecordGqlGroupByConnection[]
          | undefined;

        if (!Array.isArray(cachedGroupByConnections)) {
          return cachedGroupByQueryResult;
        }

        const { fieldVariables: queryVariables } = parseApolloStoreFieldName<
          CachedObjectRecordQueryVariables & RecordGqlOperationGroupByVariables
        >(storeFieldName);

        const queryFilter = queryVariables?.filter;
        const groupByConfig = queryVariables?.groupBy;

        const updatedGroupByConnections = cachedGroupByConnections.map(
          (groupConnection) => {
            const groupByDimensionValues =
              readField('groupByDimensionValues', groupConnection) ?? [];

            const cachedEdges =
              readField<RecordGqlRefEdge[]>('edges', groupConnection) ?? [];

            const cachedTotalCount = readField<number | undefined>(
              'totalCount',
              groupConnection,
            );

            const cachedPageInfo = readField<{
              startCursor?: string;
              endCursor?: string;
              hasNextPage?: boolean;
              hasPreviousPage?: boolean;
            }>('pageInfo', groupConnection);

            const { nextEdges, nextPageInfo, totalCountDelta } =
              processGroupByConnectionWithRecords({
                cachedEdges,
                cachedPageInfo: cachedPageInfo || {},
                records,
                operation,
                queryFilter,
                shouldMatchRootQueryFilter,
                groupByDimensionValues: Array.isArray(groupByDimensionValues)
                  ? groupByDimensionValues
                  : [],
                groupByConfig,
                objectMetadataItem,
                objectMetadataItems,
                readField,
                toReference,
              });

            if (
              totalCountDelta === 0 &&
              nextEdges.length === cachedEdges.length
            ) {
              return groupConnection;
            }

            return {
              ...groupConnection,
              edges: nextEdges,
              totalCount: isDefined(cachedTotalCount)
                ? cachedTotalCount + totalCountDelta
                : undefined,
              pageInfo: nextPageInfo,
            };
          },
        );

        if (operation === 'create' || operation === 'update') {
          const recordsToAddToNewGroups: Map<
            string,
            {
              dimensionValues: string[];
              edges: RecordGqlRefEdge[];
            }
          > = new Map();

          for (const record of records) {
            const recordMatchesFilter = isRecordMatchingFilter({
              record,
              filter: queryFilter ?? {},
              objectMetadataItem,
              objectMetadataItems,
            });

            if (
              shouldMatchRootQueryFilter &&
              !recordMatchesFilter &&
              operation === 'create'
            ) {
              continue;
            }

            if (!isDefined(groupByConfig) || groupByConfig.length === 0) {
              continue;
            }

            // TODO: see if we need to handle the case where it's not an array like for aggregate header
            if (!isArray(groupByConfig)) {
              continue;
            }

            const groupByFieldNames = groupByConfig.map(
              (groupByField) => Object.keys(groupByField)[0],
            );

            const recordDimensionValues: string[] = [];

            for (let i = 0; i < groupByFieldNames.length; i++) {
              const fieldName = groupByFieldNames[i];
              let recordValue = record[fieldName];

              if (!isDefined(recordValue)) {
                break;
              }

              const fieldConfig = groupByConfig[i][fieldName];
              const normalizedValue = normalizeGroupByDimensionValue(
                recordValue,
                fieldConfig,
              );
              recordDimensionValues.push(normalizedValue);
            }

            const dimensionKey = recordDimensionValues.join('|');
            const dimensionExists = updatedGroupByConnections.some((conn) => {
              const connDimensionValues =
                readField('groupByDimensionValues', conn) ?? [];
              return (
                Array.isArray(connDimensionValues) &&
                connDimensionValues.join('|') === dimensionKey
              );
            });

            if (
              !dimensionExists &&
              recordDimensionValues.length === groupByFieldNames.length
            ) {
              const edge = createCacheEdgeWithRecordRef({
                record,
                objectMetadataItem,
                toReference,
              });

              if (isDefined(edge)) {
                if (!recordsToAddToNewGroups.has(dimensionKey)) {
                  recordsToAddToNewGroups.set(dimensionKey, {
                    dimensionValues: recordDimensionValues,
                    edges: [],
                  });
                }

                recordsToAddToNewGroups.get(dimensionKey)!.edges.push(edge);
              }
            }
          }

          for (const [_, groupData] of recordsToAddToNewGroups) {
            if (groupData.edges.length > 0) {
              const newGroupConnection = {
                __typename: getGroupByConnectionTypename(
                  objectMetadataItem.nameSingular,
                ),
                edges: groupData.edges,
                pageInfo: {
                  hasNextPage: false,
                  hasPreviousPage: false,
                  startCursor: groupData.edges[0].cursor,
                  endCursor: groupData.edges[groupData.edges.length - 1].cursor,
                },
                totalCount: groupData.edges.length,
                groupByDimensionValues: groupData.dimensionValues,
              };

              updatedGroupByConnections.push(newGroupConnection);
            }
          }
        }

        return updatedGroupByConnections;
      },
    },
  });
};