Skip to content

The open alternative to Salesforce, designed for AI.

6.2 KB
Raw Blame
import { useCallback, useEffect, useState } from 'react';

import { fetchAllThreadMessagesOperationSignatureFactory } from '@/activities/emails/graphql/operation-signatures/factories/fetchAllThreadMessagesOperationSignatureFactory';
import { useReplyConnectedAccount } from '@/activities/emails/hooks/useReplyConnectedAccount';
import { type EmailThread } from '@/activities/emails/types/EmailThread';
import { type EmailThreadMessage } from '@/activities/emails/types/EmailThreadMessage';
import { type EmailThreadMessageParticipant } from '@/activities/emails/types/EmailThreadMessageParticipant';
import { type EmailThreadMessageWithSender } from '@/activities/emails/types/EmailThreadMessageWithSender';
import { type MessageChannelMessageAssociation } from '@/activities/emails/types/MessageChannelMessageAssociation';
import { useFindManyRecords } from '@/object-record/hooks/useFindManyRecords';
import { useFindOneRecord } from '@/object-record/hooks/useFindOneRecord';
import { useMyMessageChannels } from '@/settings/accounts/hooks/useMyMessageChannels';
import { useUpsertRecordsInStore } from '@/object-record/record-store/hooks/useUpsertRecordsInStore';
import {
  CoreObjectNameSingular,
  MessageParticipantRole,
} from 'twenty-shared/types';

export const useEmailThread = (threadId: string | null) => {
  const { upsertRecordsInStore } = useUpsertRecordsInStore();
  const { channels: viewerMessageChannels } = useMyMessageChannels();
  const [lastMessageId, setLastMessageId] = useState<string | null>(null);
  const [isMessagesFetchComplete, setIsMessagesFetchComplete] = useState(false);

  const { record: thread, loading: threadRecordLoading } =
    useFindOneRecord<EmailThread>({
      objectNameSingular: CoreObjectNameSingular.MessageThread,
      objectRecordId: threadId ?? '',
      recordGqlFields: {
        id: true,
      },
    });

  useEffect(() => {
    if (thread) {
      upsertRecordsInStore({ partialRecords: [thread] });
    }
  }, [thread, upsertRecordsInStore]);

  const FETCH_ALL_MESSAGES_OPERATION_SIGNATURE =
    fetchAllThreadMessagesOperationSignatureFactory({
      messageThreadId: threadId,
    });

  const {
    records: messages,
    loading: messagesLoading,
    fetchMoreRecords,
    hasNextPage,
    refetch: refetchMessages,
  } = useFindManyRecords<EmailThreadMessage>({
    limit: FETCH_ALL_MESSAGES_OPERATION_SIGNATURE.variables.limit,
    filter: FETCH_ALL_MESSAGES_OPERATION_SIGNATURE.variables.filter,
    objectNameSingular:
      FETCH_ALL_MESSAGES_OPERATION_SIGNATURE.objectNameSingular,
    orderBy: FETCH_ALL_MESSAGES_OPERATION_SIGNATURE.variables.orderBy,
    recordGqlFields: FETCH_ALL_MESSAGES_OPERATION_SIGNATURE.fields,
    skip: !threadId,
  });

  const fetchMoreMessages = useCallback(() => {
    if (!messagesLoading && hasNextPage) {
      fetchMoreRecords();
    } else if (!hasNextPage) {
      setIsMessagesFetchComplete(true);
    }
  }, [fetchMoreRecords, messagesLoading, hasNextPage]);

  // When all messages fit in the first page, fetchMoreMessages is never called,
  // so we need to mark fetch as complete here to unblock downstream queries
  useEffect(() => {
    if (!messagesLoading && !hasNextPage) {
      setIsMessagesFetchComplete(true);
    }
  }, [messagesLoading, hasNextPage]);

  useEffect(() => {
    if (messages.length > 0 && isMessagesFetchComplete) {
      const lastMessage = messages[messages.length - 1];

      setLastMessageId(lastMessage.id);
    }
  }, [messages, isMessagesFetchComplete]);

  const { records: messageSenders } =
    useFindManyRecords<EmailThreadMessageParticipant>({
      limit: FETCH_ALL_MESSAGES_OPERATION_SIGNATURE.variables.limit,
      filter: {
        messageId: {
          in: messages.map(({ id }) => id),
        },
        role: {
          eq: MessageParticipantRole.FROM,
        },
      },
      objectNameSingular: CoreObjectNameSingular.MessageParticipant,
      recordGqlFields: {
        id: true,
        role: true,
        displayName: true,
        messageId: true,
        handle: true,
        person: true,
        workspaceMember: true,
      },
      skip: messages.length === 0,
    });

  const {
    records: messageChannelMessageAssociations,
    loading: messageChannelMessageAssociationLoading,
  } = useFindManyRecords<MessageChannelMessageAssociation>({
    filter: {
      messageId: {
        eq: lastMessageId ?? '',
      },
    },
    objectNameSingular: CoreObjectNameSingular.MessageChannelMessageAssociation,
    recordGqlFields: {
      id: true,
      messageId: true,
      messageChannelId: true,
      messageThreadExternalId: true,
      messageExternalId: true,
    },
    skip: !lastMessageId || !isMessagesFetchComplete,
  });

  const viewerMessageChannelIds = new Set(
    viewerMessageChannels.map(({ id }) => id),
  );

  const lastMessageAssociation =
    messageChannelMessageAssociations.find(({ messageChannelId }) =>
      viewerMessageChannelIds.has(messageChannelId),
    ) ?? messageChannelMessageAssociations[0];
  const messageThreadExternalId =
    lastMessageAssociation?.messageThreadExternalId ?? null;
  const lastMessageExternalId =
    lastMessageAssociation?.messageExternalId ?? null;
  const lastMessageChannelId = lastMessageAssociation?.messageChannelId ?? null;

  const {
    connectedAccountId,
    connectedAccountHandle,
    connectedAccountProvider,
    loading: replyConnectedAccountLoading,
  } = useReplyConnectedAccount(lastMessageChannelId);

  const messagesWithSender: EmailThreadMessageWithSender[] = messages.map(
    (message) => ({
      ...message,
      sender:
        messageSenders.find(
          (messageSender) => messageSender.messageId === message.id,
        ) ??
        message.messageParticipants.find(
          (participant) => participant.role === MessageParticipantRole.FROM,
        ),
    }),
  );

  const messageChannelLoading =
    replyConnectedAccountLoading || messageChannelMessageAssociationLoading;

  return {
    thread,
    messages: messagesWithSender,
    messageThreadExternalId,
    connectedAccountId,
    connectedAccountHandle,
    connectedAccountProvider,
    threadLoading: threadRecordLoading || messagesLoading,
    messageChannelLoading,
    lastMessageExternalId,
    lastMessageChannelId,
    fetchMoreMessages,
    refetchMessages,
  };
};