Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

10.9 KB
Raw Blame
// src/pages/next-memoryes/hooks.ts

import { FilterCollection } from '@/components/list-filter-bar/interface';
import { useHandleFilterSubmit } from '@/components/list-filter-bar/use-handle-filter-submit';
import message from '@/components/ui/message';
import { ListDeletionKey } from '@/constants/list-deletion';
import { useSetModalState } from '@/hooks/common-hooks';
import { useHandleSearchChange } from '@/hooks/logic-hooks';
import { useFetchDefaultModelDictionary } from '@/hooks/use-llm-request';
import memoryService, { updateMemoryById } from '@/services/memory-service';
import { markListItemsDeleted } from '@/utils/list-deletion-util';
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { useDebounce } from 'ahooks';
import { omit } from 'lodash';
import { useCallback, useMemo, useState } from 'react';
import { useTranslation } from 'react-i18next';
import { useParams, useSearchParams } from 'react-router';
import { MemoryApiAction } from '../memory/constant';
import {
  CreateMemoryResponse,
  DeleteMemoryProps,
  DeleteMemoryResponse,
  ICreateMemoryProps,
  IMemory,
  IMemoryAppDetailProps,
  MemoryDetailResponse,
  MemoryListResponse,
  MemoryFiltersResponse,
} from './interface';

export const MemoryKeys = {
  list: () => ['memoryList'] as const,
  filters: () => ['memoryFilters'] as const,
};

export const useCreateMemory = () => {
  const { t } = useTranslation();
  const queryClient = useQueryClient();

  const {
    data,
    isError,
    isPending,
    mutateAsync: createMemoryMutation,
  } = useMutation<CreateMemoryResponse, Error, ICreateMemoryProps>({
    mutationKey: ['createMemory'],
    mutationFn: async (props) => {
      const { data: response } = await memoryService.createMemory(props);
      if (response.code !== 0) {
        throw new Error(response.message || 'Failed to create memory');
      }
      queryClient.invalidateQueries({ queryKey: MemoryKeys.list() });
      queryClient.invalidateQueries({ queryKey: MemoryKeys.filters() });
      return response.data;
    },
    onSuccess: () => {
      message.success(t('message.created'));
    },
  });

  const createMemory = useCallback(
    (props: ICreateMemoryProps) => {
      return createMemoryMutation(props);
    },
    [createMemoryMutation],
  );

  return { data, isError, isPending, createMemory };
};

export const useFetchMemoryList = () => {
  const {
    handleInputChange,
    searchString,
    setSearchString,
    pagination,
    setPagination,
  } = useHandleSearchChange();
  const { filterValue, setFilterValue, handleFilterSubmit } =
    useHandleFilterSubmit();
  const debouncedSearchString = useDebounce(searchString, { wait: 500 });

  const memoryType = Array.isArray(filterValue.memoryType)
    ? filterValue.memoryType
    : [];
  const storageType = Array.isArray(filterValue.storageType)
    ? filterValue.storageType
    : [];
  const owner = filterValue.owner;
  const requestParams: Record<string, any> = {
    keywords: debouncedSearchString,
    page_size: pagination.pageSize,
    page: pagination.current,
    memory_type: memoryType.length > 0 ? memoryType.join(',') : undefined,
    storage_type: storageType.length === 1 ? storageType[0] : undefined,
  };

  if (Array.isArray(owner) && owner.length > 0) {
    requestParams.tenant_id = owner.join(',');
  }
  const { data, isLoading, isError, refetch } = useQuery<
    MemoryListResponse,
    Error
  >({
    queryKey: [
      ...MemoryKeys.list(),
      {
        debouncedSearchString,
        ...pagination,
      },
      filterValue,
    ],
    queryFn: async () => {
      const { data: response } = await memoryService.getMemoryList(
        {
          params: requestParams,
          data: { memory_type: memoryType },
        },
        true,
      );
      if (response.code !== 0) {
        throw new Error(response.message || 'Failed to fetch memory list');
      }
      return response;
    },
  });

  // const setMemoryListParams = (newParams: MemoryListParams) => {
  //   setMemoryParams((prevParams) => ({
  //     ...prevParams,
  //     ...newParams,
  //   }));
  // };

  return {
    data,
    isLoading,
    isError,
    pagination,
    searchString,
    setSearchString,
    handleInputChange,
    setPagination,
    refetch,
    filterValue,
    setFilterValue,
    handleFilterSubmit,
  };
};

export const useFetchMemoryFilters = () => {
  const {
    data,
    isFetching: isLoading,
    isError,
  } = useQuery<MemoryFiltersResponse, Error>({
    queryKey: MemoryKeys.filters(),
    initialData: {
      filter: { owner: [], memory_type: [], storage_type: [] },
      total: 0,
    },
    queryFn: async () => {
      const { data: response } = await memoryService.getMemoryFilters(
        { params: { type: 'filter' } },
        true,
      );
      if (response.code !== 0) {
        throw new Error(response.message || 'Failed to fetch memory filters');
      }
      return response.data;
    },
  });

  return { data, isLoading, isError };
};

/** Loads the memory configuration for a route or shared memory link. */
export const useFetchMemoryDetail = (tenantId?: string) => {
  const { id } = useParams();

  const [memoryParams] = useSearchParams();
  const shared_id = memoryParams.get('shared_id');
  const memoryId = id || shared_id;

  const { data, isLoading, isError } = useQuery<MemoryDetailResponse, Error>({
    queryKey: ['memoryDetail', memoryId],
    enabled: !!memoryId && (!shared_id || !!tenantId),
    queryFn: async () => {
      if (!memoryId) {
        throw new Error('Memory id is required');
      }
      const { data: response } = await memoryService.getMemoryConfig(memoryId);
      if (response.code !== 0) {
        throw new Error(response.message || 'Failed to fetch memory detail');
      }
      return response;
    },
  });

  return { data: data?.data, isLoading, isError };
};

export const useDeleteMemory = () => {
  const { t } = useTranslation();
  const queryClient = useQueryClient();
  const {
    data,
    isError,
    mutateAsync: deleteMemoryMutation,
  } = useMutation<DeleteMemoryResponse, Error, DeleteMemoryProps>({
    mutationKey: ['deleteMemory'],
    mutationFn: async (props) => {
      const { data: response } = await memoryService.deleteMemory(
        props.memory_id,
      );
      if (response.code !== 0) {
        throw new Error(response.message || 'Failed to delete memory');
      }

      queryClient.invalidateQueries({ queryKey: MemoryKeys.list() });
      queryClient.invalidateQueries({ queryKey: MemoryKeys.filters() });
      markListItemsDeleted(ListDeletionKey.MemoryList);
      return response;
    },
    onSuccess: () => {
      message.success(t('message.deleted'));
    },
  });

  const deleteMemory = useCallback(
    (props: DeleteMemoryProps) => {
      return deleteMemoryMutation(props);
    },
    [deleteMemoryMutation],
  );

  return { data, isError, deleteMemory };
};

export const useUpdateMemory = () => {
  const { t } = useTranslation();
  const queryClient = useQueryClient();
  const {
    data,
    isError,
    isPending,
    mutateAsync: updateMemoryMutation,
  } = useMutation<any, Error, IMemoryAppDetailProps>({
    mutationKey: ['updateMemory'],
    mutationFn: async (formData) => {
      const param = omit(formData, ['id']);
      const { data: response } = await updateMemoryById(formData.id, param);
      if (response.code !== 0) {
        throw new Error(response.message || 'Failed to update memory');
      }

      return response.data;
    },
    onSuccess: (_data, variables) => {
      message.success(t('message.updated'));
      queryClient.invalidateQueries({
        queryKey: ['memoryDetail', variables.id],
      });
      queryClient.invalidateQueries({
        queryKey: [MemoryApiAction.FetchMemoryDetail],
      });
      queryClient.invalidateQueries({ queryKey: MemoryKeys.list() });
      queryClient.invalidateQueries({ queryKey: MemoryKeys.filters() });
    },
  });

  const updateMemory = useCallback(
    (formData: IMemoryAppDetailProps) => {
      return updateMemoryMutation(formData);
    },
    [updateMemoryMutation],
  );

  return { data, isError, isPending, updateMemory };
};

export const useRenameMemory = () => {
  const [memory, setMemory] = useState<IMemory>({} as IMemory);
  const {
    visible: openCreateModal,
    hideModal: hideChatRenameModal,
    showModal: showChatRenameModal,
  } = useSetModalState();
  const { isPending: createPending, createMemory } = useCreateMemory();
  const { isPending: updatePending, updateMemory } = useUpdateMemory();
  const memoryRenameLoading = createPending || updatePending;
  const defaultModelDictionary = useFetchDefaultModelDictionary();

  const handleShowChatRenameModal = useCallback(
    (record?: IMemory) => {
      if (record) {
        const embd_id = record.embd_id || defaultModelDictionary?.embd_id;
        const llm_id = record.llm_id || defaultModelDictionary?.llm_id;
        setMemory({
          ...record,
          embd_id,
          llm_id,
        });
      }
      showChatRenameModal();
    },
    [showChatRenameModal, defaultModelDictionary],
  );

  const handleHideModal = useCallback(() => {
    hideChatRenameModal();
    setMemory({} as IMemory);
  }, [hideChatRenameModal]);

  const onMemoryRenameOk = useCallback(
    async (data: ICreateMemoryProps, callBack?: () => void) => {
      let saved = false;
      try {
        if (memory?.id) {
          await updateMemory({
            name: data.name,
            id: memory.id,
          } as unknown as IMemoryAppDetailProps);
        } else {
          await createMemory(data);
        }
        saved = true;
      } catch {
        // Request failures are already reported by the request layer; keep
        // the dialog open so the user can retry.
      }
      if (saved) {
        callBack?.();
        handleHideModal();
      }
    },
    [memory, createMemory, handleHideModal, updateMemory],
  );
  return {
    memoryRenameLoading,
    initialMemory: memory,
    onMemoryRenameOk,
    openCreateModal,
    hideMemoryModal: handleHideModal,
    showMemoryRenameModal: handleShowChatRenameModal,
  };
};

/**
 * Build the filter facet collections from the server-side aggregation query.
 *
 * @param filterData - Server-side filter aggregations for visible memories.
 * @returns The filter collections consumed by ListFilterBar.
 *
 * @example
 * const { data: list } = useFetchMemoryList();
 * const { filters } = useSelectFilters(list?.data?.memory_list ?? []);
 */
export function useSelectFilters(filterData: MemoryFiltersResponse) {
  const { t } = useTranslation();

  const filters: FilterCollection[] = useMemo(() => {
    return [
      {
        field: 'owner',
        list: filterData.filter.owner,
        label: t('common.owner'),
      },
      {
        field: 'memoryType',
        list: filterData.filter.memory_type,
        label: t('memories.memoryType'),
      },
      {
        field: 'storageType',
        list: filterData.filter.storage_type,
        label: t('memory.config.storageType'),
      },
    ];
  }, [filterData, t]);

  return { filters };
}