UILD-399: Browse function for Authority lookup

src/common/api/search.api.ts

@@ -44,19 +44,35 @@ export const getSearchData = (url?: string, urlParams?: Record<string, string>)
 };
 
 export const getSearchResults = async (params: Record<string, string | number>) => {
-  const { endpointUrl, query, offset = '0', limit = SEARCH_RESULTS_LIMIT.toString(), resultsContainer } = params;
+  const {
+    endpointUrl,
+    query,
+    offset,
+    limit = SEARCH_RESULTS_LIMIT.toString(),
+    resultsContainer,
+    precedingRecordsCount,
+  } = params;
 
   const urlParams: Record<string, string> | undefined = {
     query: query as string,
-    offset: offset?.toString(),
     limit: limit?.toString(),
   };
 
+  if (offset) {
+    urlParams.offset = offset?.toString();
+  }
+
+  if (precedingRecordsCount) {
+    urlParams.precedingRecordsCount = precedingRecordsCount.toString();
+  }
+
   const result = await baseApi.getJson({ url: endpointUrl as string, urlParams });
 
   return {
     content: result.content ?? result[resultsContainer],
     totalRecords: result.totalRecords,
     totalPages: result.totalPages ?? Math.ceil(result?.totalRecords / +limit),
+    prev: result.prev,
+    next: result.next,
   };
 };

src/common/constants/complexLookup.constants.ts

@@ -16,6 +16,12 @@ export enum SearchableIndex {
   Genre = 'genre',
 }
 
+export enum SearchableIndexQuerySelector {
+  Query = 'query',
+  Prev = 'prev',
+  Next = 'next',
+}
+
 export const COMPLEX_LOOKUPS_LINKED_FIELDS_MAPPING = {
   subclass: {
     PERSON: {

src/common/constants/search.constants.ts

@@ -94,6 +94,8 @@ export type AdvancedSearchSchema = AdvancedSearchSchemaRow[];
 
 export const SEARCH_RESULTS_LIMIT = 10;
 
+export const BROWSE_PRECEDING_RECORDS_COUNT = 5;
+
 export const SELECT_IDENTIFIERS = Object.values(SearchIdentifiers);
 
 export const SELECT_OPERATORS = Object.values(AdvancedSearchOperators);

src/common/helpers/search/formatters/authorities.ts

@@ -1,16 +1,20 @@
 import { v4 as uuidv4 } from 'uuid';
 
 export const formatAuthorityItem = (
-  authoritiesList: AuthorityAsSearchResultDTO[],
+  authoritiesList: AuthorityAsSearchResultDTO[] | AuthorityAsBrowseResultDTO[],
   sourceData?: SourceDataDTO,
 ): SearchResultsTableRow[] =>
-  authoritiesList?.map(({ id, authRefType, headingRef, headingType, sourceFileId }) => {
+  authoritiesList?.map(authorityEntry => {
+    const selectedEntry = (authorityEntry.authority ?? authorityEntry) as AuthorityAsSearchResultDTO;
+    const { id = '', authRefType = '', headingRef = '', headingType = '', sourceFileId = '' } = selectedEntry;
     const sourceLabel = sourceData?.find(({ id: sourceId }) => sourceId === sourceFileId)?.name ?? sourceFileId;
+    const { isAnchor } = authorityEntry;
 
     return {
       __meta: {
         id,
         key: uuidv4(),
+        isAnchor,
       },
       authorized: {
         label: authRefType,

src/common/helpers/search/formatters/index.ts

@@ -4,5 +4,6 @@ export const SEARCH_RESULTS_FORMATTER: Record<
   string,
   (data: any, sourceData?: SourceDataDTO) => SearchResultsTableRow[]
 > = {
+  default: formatAuthorityItem,
   authorities: formatAuthorityItem,
 };

src/common/helpers/search/queryBuilder/authorities.ts

@@ -0,0 +1,15 @@
+import { SearchableIndexQuerySelector } from '@common/constants/complexLookup.constants';
+import { SEARCH_QUERY_VALUE_PARAM } from '@common/constants/search.constants';
+
+export const buildSearchQuery = ({
+  map,
+  selector = SearchableIndexQuerySelector.Query,
+  searchBy,
+  value,
+}: BuildSearchQueryParams) => {
+  const searchableIndex = map?.[searchBy];
+
+  return searchableIndex?.[selector]?.replaceAll(SEARCH_QUERY_VALUE_PARAM, value);
+};
+
+export const buildBrowseQuery = () => {};

src/common/helpers/search/queryBuilder/index.ts

@@ -1 +1,9 @@
-export { buildSearchQuery } from './queryBuilder';
+import { buildSearchQuery } from './authorities';
+
+export const SEARCH_QUERY_BUILDER: Record<
+  string,
+  ({ map, selector, searchBy, value }: BuildSearchQueryParams) => string | undefined
+> = {
+  default: buildSearchQuery,
+  authorities: buildSearchQuery,
+};

src/common/hooks/useComplexLookupApi.ts

@@ -1,10 +1,6 @@
-import { useEffect } from 'react';
-import { useResetRecoilState } from 'recoil';
-import state from '@state';
 import { useSearchFiltersData } from './useSearchFiltersData';
 
-export const useComplexLookupApi = (api: ComplexLookupApiEntryConfig, filters: SearchFilters, isOpen: boolean) => {
-  const resetFacetsData = useResetRecoilState(state.search.facetsData);
+export const useComplexLookupApi = (api: ComplexLookupApiEntryConfig, filters: SearchFilters) => {
   const { getSearchSourceData, getSearchFacetsData } = useSearchFiltersData();
 
   const getFacetsData = async (facet?: string, isOpen?: boolean) => {
@@ -18,16 +14,6 @@ export const useComplexLookupApi = (api: ComplexLookupApiEntryConfig, filters: S
     await getFacetsData(openedFilter?.facet);
   };
 
-  useEffect(() => {
-    if (!isOpen || !api.endpoints.source) return;
-
-    getSourceData();
-
-    return () => {
-      resetFacetsData();
-    };
-  }, [isOpen]);
-
   return {
     getFacetsData,
     getSourceData,

src/common/hooks/useFetchSearchData.ts

@@ -0,0 +1,201 @@
+import { useCallback } from 'react';
+import { useSetRecoilState, useRecoilState, SetterOrUpdater, useResetRecoilState } from 'recoil';
+import { getByIdentifier } from '@common/api/search.api';
+import { SearchIdentifiers, SearchSegment } from '@common/constants/search.constants';
+import { SearchableIndexQuerySelector } from '@common/constants/complexLookup.constants';
+import { StatusType } from '@common/constants/status.constants';
+import { normalizeQuery } from '@common/helpers/search.helper';
+import { normalizeLccn } from '@common/helpers/validations.helper';
+import { UserNotificationFactory } from '@common/services/userNotification';
+import state from '@state';
+import { useSearchContext } from './useSearchContext';
+
+export const useFetchSearchData = () => {
+  const {
+    endpointUrl,
+    searchFilter,
+    isSortedResults,
+    navigationSegment,
+    endpointUrlsBySegments,
+    searchResultsLimit,
+    fetchSearchResults,
+    searchResultsContainer,
+    searchableIndicesMap,
+    buildSearchQuery,
+    precedingRecordsCount,
+  } = useSearchContext();
+  const setIsLoading = useSetRecoilState(state.loadingState.isLoading);
+  const setMessage = useSetRecoilState(state.search.message);
+  const [data, setData] = useRecoilState(state.search.data);
+  const resetData = useResetRecoilState(state.search.data);
+  const setPageMetadata = useSetRecoilState(state.search.pageMetadata);
+  const setStatusMessages = useSetRecoilState(state.status.commonMessages);
+  const resetStatusMessage = useResetRecoilState(state.status.commonMessages);
+
+  const validateAndNormalizeQuery = useCallback(
+    (type: SearchIdentifiers, query: string) => {
+      if (type === SearchIdentifiers.LCCN) {
+        const normalized = normalizeLccn(query);
+
+        !normalized && setMessage('ld.searchInvalidLccn');
+
+        return normalized;
+      }
+
+      return normalizeQuery(query);
+    },
+    [setMessage],
+  );
+
+  const getEndpointUrl = ({
+    selectedSegment,
+    endpointUrlsBySegments,
+    endpointUrl,
+  }: {
+    selectedSegment?: string;
+    endpointUrlsBySegments?: EndpointUrlsBySegments;
+    endpointUrl: string;
+  }) => {
+    return selectedSegment ? endpointUrlsBySegments?.[selectedSegment] : endpointUrl;
+  };
+
+  const generateQuery = ({
+    searchBy,
+    query,
+    selectedSegment,
+    searchableIndicesMap,
+    baseQuerySelector,
+  }: {
+    searchBy: SearchableIndexType;
+    query: string;
+    selectedSegment?: string;
+    searchableIndicesMap?: SearchableIndicesMap;
+    baseQuerySelector?: SearchableIndexQuerySelector;
+  }) => {
+    const selectedSearchableIndices = selectedSegment
+      ? searchableIndicesMap?.[selectedSegment as SearchSegmentValue]
+      : searchableIndicesMap;
+
+    return (
+      buildSearchQuery?.({
+        map: selectedSearchableIndices as SearchableIndexEntries,
+        selector: baseQuerySelector,
+        searchBy,
+        value: query,
+      }) ?? query
+    );
+  };
+
+  const fetchDataFromApi = async ({
+    endpointUrl,
+    searchFilter,
+    isSortedResults,
+    searchBy,
+    query,
+    offset,
+    limit,
+    precedingRecordsCount,
+    resultsContainer,
+  }: {
+    endpointUrl: string;
+    searchFilter?: string;
+    isSortedResults?: boolean;
+    searchBy: SearchIdentifiers;
+    query: string;
+    offset?: string;
+    limit?: string;
+    precedingRecordsCount?: number;
+    resultsContainer: any;
+  }) => {
+    return fetchSearchResults
+      ? await fetchSearchResults({
+          endpointUrl,
+          searchFilter,
+          isSortedResults,
+          searchBy,
+          query,
+          offset,
+          limit,
+          precedingRecordsCount,
+          resultsContainer,
+        })
+      : await getByIdentifier({
+          endpointUrl,
+          searchFilter,
+          isSortedResults,
+          searchBy,
+          query,
+          offset,
+          limit,
+        });
+  };
+
+  const handleFetchError = (setStatusMessages: SetterOrUpdater<StatusEntry[]>) => {
+    setStatusMessages(currentStatus => [
+      ...currentStatus,
+      UserNotificationFactory.createMessage(StatusType.error, 'ld.errorFetching'),
+    ]);
+  };
+
+  const fetchData = useCallback(
+    async ({
+      query,
+      searchBy,
+      offset,
+      selectedSegment,
+      baseQuerySelector = SearchableIndexQuerySelector.Query,
+    }: FetchDataParams) => {
+      resetStatusMessage();
+      const selectedNavigationSegment = selectedSegment ?? navigationSegment?.value;
+
+      data && resetData();
+
+      const updatedQuery = validateAndNormalizeQuery(searchBy, query);
+      if (!updatedQuery) return;
+
+      setIsLoading(true);
+
+      try {
+        const currentEndpointUrl = getEndpointUrl({
+          selectedSegment: selectedNavigationSegment,
+          endpointUrlsBySegments,
+          endpointUrl,
+        });
+        const generatedQuery = generateQuery({
+          searchBy,
+          query: updatedQuery,
+          selectedSegment: selectedNavigationSegment,
+          searchableIndicesMap,
+          baseQuerySelector,
+        });
+        const isBrowseSearch = selectedNavigationSegment === SearchSegment.Browse;
+
+        const result = await fetchDataFromApi({
+          endpointUrl: currentEndpointUrl ?? '',
+          searchFilter,
+          isSortedResults,
+          searchBy,
+          query: generatedQuery,
+          offset: offset?.toString(),
+          limit: searchResultsLimit?.toString(),
+          precedingRecordsCount: isBrowseSearch ? precedingRecordsCount : undefined,
+          resultsContainer: searchResultsContainer?.[selectedNavigationSegment as SearchSegmentValue],
+        });
+
+        const { content, totalPages, totalRecords, prev, next } = result;
+
+        if (!content.length) return setMessage('ld.searchNoRdsMatch');
+
+        setData(content);
+        setPageMetadata({ totalPages, totalElements: totalRecords, prev, next });
+      } catch {
+        handleFetchError(setStatusMessages);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [data, endpointUrl, fetchSearchResults, navigationSegment?.value, searchFilter, isSortedResults],
+  );
+
+  return { fetchData };
+};