Skip to content

The open alternative to Salesforce, designed for AI.

7.4 KB
Raw Blame
import { objectMetadataItemsSelector } from '@/object-metadata/states/objectMetadataItemsSelector';
import { UPSERT_VIEW_WIDGET } from '@/page-layout/graphql/mutations/upsertViewWidget';
import { useHasRecordTableWidgetViewChanges } from '@/page-layout/hooks/useHasRecordTableWidgetViewChanges';
import { pageLayoutDraftComponentState } from '@/page-layout/states/pageLayoutDraftComponentState';
import { recordTableWidgetViewDraftComponentState } from '@/page-layout/states/recordTableWidgetViewDraftComponentState';
import { recordTableWidgetViewPersistedComponentState } from '@/page-layout/states/recordTableWidgetViewPersistedComponentState';
import { getWidgetConfigurationViewId } from '@/page-layout/utils/getWidgetConfigurationViewId';
import { widgetUsesRecordTableView } from '@/page-layout/utils/widgetUsesRecordTableView';
import { buildUpsertViewWidgetViewSettingsInput } from '@/page-layout/widgets/record-table/utils/buildUpsertViewWidgetViewSettingsInput';
import { normalizeRecordTableWidgetViewFields } from '@/page-layout/widgets/record-table/utils/normalizeRecordTableWidgetViewFields';
import { useMutation } from '@apollo/client/react';
import { useStore } from 'jotai';
import { useCallback } from 'react';
import { isDefined } from 'twenty-shared/utils';
import { isDeeplyEqual } from '~/utils/isDeeplyEqual';
import {
  type UpsertViewWidgetInput,
  type ViewFragmentFragment,
} from '~/generated-metadata/graphql';

export const useSaveRecordTableWidgetViews = () => {
  const [upsertViewWidgetMutation] = useMutation<
    { upsertViewWidget: ViewFragmentFragment },
    { input: UpsertViewWidgetInput }
  >(UPSERT_VIEW_WIDGET);

  const { hasRecordTableWidgetViewChanges } =
    useHasRecordTableWidgetViewChanges();

  const store = useStore();

  const saveRecordTableWidgetViews = useCallback(
    async (pageLayoutId: string) => {
      if (!hasRecordTableWidgetViewChanges(pageLayoutId)) {
        return;
      }

      const draft = store.get(
        pageLayoutDraftComponentState.atomFamily({
          instanceId: pageLayoutId,
        }),
      );

      const recordTableWidgetViewDraft = store.get(
        recordTableWidgetViewDraftComponentState.atomFamily({
          instanceId: pageLayoutId,
        }),
      );

      const recordTableWidgetViewPersisted = store.get(
        recordTableWidgetViewPersistedComponentState.atomFamily({
          instanceId: pageLayoutId,
        }),
      );

      const draftRecordTableWidgets = draft.tabs
        .flatMap((tab) => tab.widgets)
        .filter(widgetUsesRecordTableView);

      const objectMetadataItems = store.get(objectMetadataItemsSelector.atom);

      let normalizedRecordTableWidgetViewDraft = recordTableWidgetViewDraft;

      for (const widget of draftRecordTableWidgets) {
        const viewId = getWidgetConfigurationViewId(widget.configuration);

        if (!isDefined(viewId)) {
          continue;
        }

        const widgetViewDraft = recordTableWidgetViewDraft[widget.id];

        if (!isDefined(widgetViewDraft)) {
          continue;
        }

        // Every view-backed widget gets a draft on entering edit mode; only touched ones need an upsert.
        if (
          isDeeplyEqual(
            recordTableWidgetViewPersisted[widget.id],
            widgetViewDraft,
          )
        ) {
          continue;
        }

        const objectMetadataItem = objectMetadataItems.find(
          (objectMetadataItem) =>
            objectMetadataItem.id === widgetViewDraft.view.objectMetadataId,
        );

        const normalizedViewFields = isDefined(objectMetadataItem)
          ? normalizeRecordTableWidgetViewFields({
              viewFields: widgetViewDraft.viewFields,
              labelIdentifierFieldMetadataId:
                objectMetadataItem.labelIdentifierFieldMetadataId,
            })
          : widgetViewDraft.viewFields;

        const normalizedWidgetViewDraft = {
          ...widgetViewDraft,
          viewFields: normalizedViewFields,
        };

        const persistedView = recordTableWidgetViewPersisted[widget.id]?.view;

        const draftViewSettings = buildUpsertViewWidgetViewSettingsInput(
          widgetViewDraft.view,
        );

        const hasViewSettingsChanges =
          !isDefined(persistedView) ||
          !isDeeplyEqual(
            buildUpsertViewWidgetViewSettingsInput(persistedView),
            draftViewSettings,
          );

        const { data } = await upsertViewWidgetMutation({
          variables: {
            input: {
              widgetId: widget.id,
              ...(hasViewSettingsChanges ? { view: draftViewSettings } : {}),
              viewFields: normalizedWidgetViewDraft.viewFields.map((field) => ({
                fieldMetadataId: field.fieldMetadataId,
                isVisible: field.isVisible,
                position: field.position,
                size: field.size,
                aggregateOperation: field.aggregateOperation ?? null,
              })),
              viewFilters: widgetViewDraft.viewFilters.map((filter) => ({
                id: filter.id,
                fieldMetadataId: filter.fieldMetadataId,
                operand: filter.operand,
                value: filter.value,
                viewFilterGroupId: filter.viewFilterGroupId ?? undefined,
                positionInViewFilterGroup:
                  filter.positionInViewFilterGroup ?? undefined,
                subFieldName: filter.subFieldName ?? undefined,
                relationTargetFieldMetadataId:
                  filter.relationTargetFieldMetadataId ?? undefined,
              })),
              viewFilterGroups: widgetViewDraft.viewFilterGroups.map(
                (group) => ({
                  id: group.id,
                  parentViewFilterGroupId:
                    group.parentViewFilterGroupId ?? undefined,
                  logicalOperator: group.logicalOperator,
                  positionInViewFilterGroup:
                    group.positionInViewFilterGroup ?? undefined,
                }),
              ),
              viewSorts: widgetViewDraft.viewSorts.map((sort) => ({
                id: sort.id,
                fieldMetadataId: sort.fieldMetadataId,
                direction: sort.direction,
              })),
            },
          },
        });

        // The server regenerates view groups from mainGroupByFieldMetadataId, so store its rows, not draft ids.
        const upsertedViewGroups = data?.upsertViewWidget.viewGroups;

        normalizedRecordTableWidgetViewDraft = {
          ...normalizedRecordTableWidgetViewDraft,
          [widget.id]: {
            ...normalizedWidgetViewDraft,
            viewGroups: isDefined(upsertedViewGroups)
              ? upsertedViewGroups.map((viewGroup) => ({
                  id: viewGroup.id,
                  viewId: viewGroup.viewId,
                  fieldValue: viewGroup.fieldValue,
                  position: viewGroup.position,
                  isVisible: viewGroup.isVisible,
                }))
              : normalizedWidgetViewDraft.viewGroups,
          },
        };
      }

      store.set(
        recordTableWidgetViewDraftComponentState.atomFamily({
          instanceId: pageLayoutId,
        }),
        normalizedRecordTableWidgetViewDraft,
      );

      store.set(
        recordTableWidgetViewPersistedComponentState.atomFamily({
          instanceId: pageLayoutId,
        }),
        normalizedRecordTableWidgetViewDraft,
      );
    },
    [hasRecordTableWidgetViewChanges, store, upsertViewWidgetMutation],
  );

  return { saveRecordTableWidgetViews };
};