rastack 0.0.16 → 0.0.19

package/hooks/query/list.ts

@@ -1,286 +1,286 @@
-import { AxiosResponse } from "axios";
-import { useQuery } from "react-query";
-import { useEffect, useState } from "react";
-import {
-  IFilterActions,
-  IListQuery,
-  IPaginatedResponse,
-  IPaginationActions,
-  ISearchingActions,
-  ISortingActions,
-  ListQueryOptions,
-  NormalizedField,
-} from "./interfaces";
-import { stringifyQueryParams } from "./url";
-import { useDebounceValue } from "usehooks-ts";
-import { API } from "./api";
-import { ExtractKey } from "../../types";
-
-export interface GetPaginatedQueryListProps<TParam, TResult> {
-  postUrl?: string;
-  getUrl?: string;
-  queryKey: string;
-  pathParameters: (keyof TParam)[];
-  isAuthenticated: boolean;
-  options?: ListQueryOptions<TParam, TResult>;
-}
-
-export function useGetPaginatedQueryList<TParam, TResult>({
-  postUrl,
-  getUrl,
-  queryKey,
-  pathParameters,
-  isAuthenticated,
-  options,
-}: GetPaginatedQueryListProps<TParam, TResult>): IListQuery<TParam, TResult> {
-  const [searchText, setSearchText] = useState<string | undefined>(undefined);
-  const [serverSearchText, setServerSearchText] = useDebounceValue<
-    string | undefined
-  >(undefined, 500);
-
-  const [queryParamState, setQueryParamState] = useState({
-    page: 1,
-    page_size: options?.pageSize ? options?.pageSize : 20,
-    order_by: options?.defaultSortFields ?? [],
-  });
-
-  const pageParams = ["page", "page_size"] as unknown as (keyof TParam)[];
-  const requiredParams = options?.requiredParams
-    ? [...options.requiredParams, ...pageParams]
-    : pageParams;
-
-  useEffect(() => {
-    if (!options?.localCache) {
-      setServerSearchText(searchText);
-    }
-  }, [searchText]);
-
-  useEffect(() => {
-    if (options?.searchKey) {
-      setQueryParamState((current) => ({
-        ...current,
-        page: 1,
-        [options?.searchKey as string]: serverSearchText,
-      }));
-    }
-  }, [serverSearchText]);
-
-  const serverQueryParamState = {
-    ...queryParamState,
-    ...options?.params,
-  };
-
-  const isRequiredQueryParamsPresent = requiredParams?.every(
-    // @ts-ignore Pre Validation of page, page_size and order_by will happen when the two hooks are combined
-    (param) => serverQueryParamState[param] !== undefined,
-  );
-
-  const fetchDataForAllPages = async (
-    currentPage: number = 1,
-    accumulatedData: TResult[] = [],
-  ): Promise<IPaginatedResponse<TResult>> => {
-    const serverURL = `${getUrl}?${stringifyQueryParams(pathParameters, {
-      ...serverQueryParamState,
-      // @ts-ignore Pre Validation of page, page_size and order_by will happen when the two hooks are combined
-      page: currentPage,
-    })}`;
-
-    const response: AxiosResponse<IPaginatedResponse<TResult>> = postUrl
-      ? await API.post(postUrl, serverQueryParamState)
-      : await API.get(serverURL);
-
-    // @ts-ignore This will be resolved when the List and Get endpoints will be merged
-    const newData = response.data.results;
-
-    const mergedData = [...accumulatedData, ...newData];
-
-    if (currentPage < response.data.pagination.last) {
-      return fetchDataForAllPages(currentPage + 1, mergedData);
-    } else {
-      return {
-        ...response.data,
-        pagination: {
-          current: 1,
-          last: 1,
-          next: 1,
-          previous: 1,
-          page_size: mergedData.length,
-          count: mergedData.length,
-        },
-        results: mergedData,
-      };
-    }
-  };
-
-  const fetchData = async () => {
-    if (options?.localCache) {
-      return fetchDataForAllPages();
-    } else {
-      // @ts-ignore Pre Validation of page, page_size and order_by will happen when the two hooks are combined
-      const serverURL = `${getUrl}?${stringifyQueryParams(pathParameters, serverQueryParamState)}`;
-      const response: AxiosResponse<IPaginatedResponse<TResult>> = postUrl
-        ? await API.post(postUrl, serverQueryParamState)
-        : await API.get(serverURL);
-      return response.data;
-    }
-  };
-
-  const query = useQuery<IPaginatedResponse<TResult>>(
-    [queryKey, getUrl, options?.params, serverQueryParamState],
-    fetchData,
-    {
-      enabled: isRequiredQueryParamsPresent && isAuthenticated,
-      onSuccess: options?.onSuccess,
-    },
-  );
-
-  const pageCount = query.data?.pagination?.last || 0;
-  const itemCount = query.data?.pagination?.count || 0;
-
-  function previousPage() {
-    if (queryParamState.page) {
-      const previousPage = (queryParamState.page as unknown as number) - 1;
-      setQueryParamState((current) => ({
-        ...current,
-        page: previousPage < 1 ? 1 : previousPage,
-      }));
-    }
-  }
-
-  function nextPage() {
-    if (queryParamState.page) {
-      const nextPage = (queryParamState.page as unknown as number) + 1;
-      setQueryParamState((current) => ({
-        ...current,
-        page: nextPage > pageCount ? pageCount : nextPage,
-      }));
-    }
-  }
-
-  function setPageSize(pageSize: number) {
-    setQueryParamState((current) => ({
-      ...current,
-      page_size: pageSize,
-    }));
-  }
-
-  const pagination: IPaginationActions = {
-    previousPage,
-    nextPage,
-    currentPage: serverQueryParamState.page,
-    pageSize: serverQueryParamState.page_size,
-    pageCount,
-    itemCount,
-    setPageSize,
-  };
-
-  const searching: ISearchingActions<TParam> = {
-    searchText,
-    setSearchText,
-  };
-
-  function sortField(field: NormalizedField<ExtractKey<TParam, "order_by">>) {
-    setQueryParamState((current) => {
-      const ascendingField = current.order_by?.find((item) => item === field);
-      const descendingField = current.order_by?.find(
-        (item) => item === `-${field}`,
-      );
-
-      let result: (string & ExtractKey<TParam, "order_by">)[] | undefined = [];
-      if (descendingField) {
-        result = current.order_by?.filter((item) => item !== `-${field}`);
-      } else if (ascendingField) {
-        result = current.order_by?.filter((item) => item !== field);
-        result?.push(`-${field}` as string & ExtractKey<TParam, "order_by">);
-      } else {
-        result = current.order_by
-          ? [
-              ...current.order_by,
-              field as string & ExtractKey<TParam, "order_by">,
-            ]
-          : [field as string & ExtractKey<TParam, "order_by">];
-      }
-
-      return {
-        ...current,
-        order_by: result,
-        page: 1,
-      };
-    });
-  }
-
-  function getSortingDirection(
-    field: NormalizedField<ExtractKey<TParam, "order_by">>,
-  ) {
-    const invertedField = `-${field}`;
-    if (serverQueryParamState.order_by?.find((item) => item === field)) {
-      return "asc";
-    } else if (
-      serverQueryParamState.order_by?.find((item) => item === invertedField)
-    ) {
-      return "desc";
-    } else {
-      return undefined;
-    }
-  }
-
-  const sorting: ISortingActions<TParam> = {
-    sortField,
-    getSortingDirection,
-  };
-
-  function getFilterFieldValue(key: keyof TParam) {
-    // @ts-ignore correctly handle the keyof in the future
-    return queryParamState[key] as TParam[keyof TParam];
-  }
-
-  function setFilterFieldValue(key: keyof TParam) {
-    return (value: unknown) => {
-      setQueryParamState((current) => ({
-        ...current,
-        [key]: value,
-        page: 1,
-      }));
-    };
-  }
-
-  const filtering: IFilterActions<TParam> = {
-    getFilterFieldValue,
-    setFilterFieldValue,
-  };
-
-  const data =
-    options?.localCache && searchText
-      ? // @ts-ignore the results key is based on the interface returned. This will get sorted out in a future version
-        query.data?.results.filter((value: any) => {
-          if (options.localSearchFunction && searchText) {
-            if (searchText.includes(" ")) {
-              const searchWords = searchText.split(" ");
-              return searchWords.every((word) => {
-                if (options.localSearchFunction) {
-                  return options.localSearchFunction(word, value);
-                } else {
-                  return false;
-                }
-              });
-            } else {
-              return options.localSearchFunction(searchText, value);
-            }
-          } else {
-            return true;
-          }
-        })
-      : // @ts-ignore
-        query.data?.results;
-
-  return {
-    ...query,
-    raw: query.data,
-    data,
-    header: query.data?.headers,
-    pagination,
-    searching,
-    sorting,
-    filtering,
-  };
-}
+import { AxiosResponse } from "axios";
+import { useQuery } from "react-query";
+import { useEffect, useState } from "react";
+import {
+  IFilterActions,
+  IListQuery,
+  IPaginatedResponse,
+  IPaginationActions,
+  ISearchingActions,
+  ISortingActions,
+  ListQueryOptions,
+  NormalizedField,
+} from "./interfaces";
+import { stringifyQueryParams } from "./url";
+import { useDebounceValue } from "usehooks-ts";
+import { API } from "./api";
+import { ExtractKey } from "../../types";
+
+export interface GetPaginatedQueryListProps<TParam, TResult> {
+  postUrl?: string;
+  getUrl?: string;
+  queryKey: string;
+  pathParameters: (keyof TParam)[];
+  isAuthenticated: boolean;
+  options?: ListQueryOptions<TParam, TResult>;
+}
+
+export function useGetPaginatedQueryList<TParam, TResult>({
+  postUrl,
+  getUrl,
+  queryKey,
+  pathParameters,
+  isAuthenticated,
+  options,
+}: GetPaginatedQueryListProps<TParam, TResult>): IListQuery<TParam, TResult> {
+  const [searchText, setSearchText] = useState<string | undefined>(undefined);
+  const [serverSearchText, setServerSearchText] = useDebounceValue<
+    string | undefined
+  >(undefined, 500);
+
+  const [queryParamState, setQueryParamState] = useState({
+    page: 1,
+    page_size: options?.pageSize ? options?.pageSize : 20,
+    order_by: options?.defaultSortFields ?? [],
+  });
+
+  const pageParams = ["page", "page_size"] as unknown as (keyof TParam)[];
+  const requiredParams = options?.requiredParams
+    ? [...options.requiredParams, ...pageParams]
+    : pageParams;
+
+  useEffect(() => {
+    if (!options?.localCache) {
+      setServerSearchText(searchText);
+    }
+  }, [searchText]);
+
+  useEffect(() => {
+    if (options?.searchKey) {
+      setQueryParamState((current) => ({
+        ...current,
+        page: 1,
+        [options?.searchKey as string]: serverSearchText,
+      }));
+    }
+  }, [serverSearchText]);
+
+  const serverQueryParamState = {
+    ...queryParamState,
+    ...options?.params,
+  };
+
+  const isRequiredQueryParamsPresent = requiredParams?.every(
+    // @ts-ignore Pre Validation of page, page_size and order_by will happen when the two hooks are combined
+    (param) => serverQueryParamState[param] !== undefined,
+  );
+
+  const fetchDataForAllPages = async (
+    currentPage: number = 1,
+    accumulatedData: TResult[] = [],
+  ): Promise<IPaginatedResponse<TResult>> => {
+    const serverURL = `${getUrl}?${stringifyQueryParams(pathParameters, {
+      ...serverQueryParamState,
+      // @ts-ignore Pre Validation of page, page_size and order_by will happen when the two hooks are combined
+      page: currentPage,
+    })}`;
+
+    const response: AxiosResponse<IPaginatedResponse<TResult>> = postUrl
+      ? await API.post(postUrl, serverQueryParamState)
+      : await API.get(serverURL);
+
+    // @ts-ignore This will be resolved when the List and Get endpoints will be merged
+    const newData = response.data.results;
+
+    const mergedData = [...accumulatedData, ...newData];
+
+    if (currentPage < response.data.pagination.last) {
+      return fetchDataForAllPages(currentPage + 1, mergedData);
+    } else {
+      return {
+        ...response.data,
+        pagination: {
+          current: 1,
+          last: 1,
+          next: 1,
+          previous: 1,
+          page_size: mergedData.length,
+          count: mergedData.length,
+        },
+        results: mergedData,
+      };
+    }
+  };
+
+  const fetchData = async () => {
+    if (options?.localCache) {
+      return fetchDataForAllPages();
+    } else {
+      // @ts-ignore Pre Validation of page, page_size and order_by will happen when the two hooks are combined
+      const serverURL = `${getUrl}?${stringifyQueryParams(pathParameters, serverQueryParamState)}`;
+      const response: AxiosResponse<IPaginatedResponse<TResult>> = postUrl
+        ? await API.post(postUrl, serverQueryParamState)
+        : await API.get(serverURL);
+      return response.data;
+    }
+  };
+
+  const query = useQuery<IPaginatedResponse<TResult>>(
+    [queryKey, getUrl, options?.params, serverQueryParamState],
+    fetchData,
+    {
+      enabled: isRequiredQueryParamsPresent && isAuthenticated,
+      onSuccess: options?.onSuccess,
+    },
+  );
+
+  const pageCount = query.data?.pagination?.last || 0;
+  const itemCount = query.data?.pagination?.count || 0;
+
+  function previousPage() {
+    if (queryParamState.page) {
+      const previousPage = (queryParamState.page as unknown as number) - 1;
+      setQueryParamState((current) => ({
+        ...current,
+        page: previousPage < 1 ? 1 : previousPage,
+      }));
+    }
+  }
+
+  function nextPage() {
+    if (queryParamState.page) {
+      const nextPage = (queryParamState.page as unknown as number) + 1;
+      setQueryParamState((current) => ({
+        ...current,
+        page: nextPage > pageCount ? pageCount : nextPage,
+      }));
+    }
+  }
+
+  function setPageSize(pageSize: number) {
+    setQueryParamState((current) => ({
+      ...current,
+      page_size: pageSize,
+    }));
+  }
+
+  const pagination: IPaginationActions = {
+    previousPage,
+    nextPage,
+    currentPage: serverQueryParamState.page,
+    pageSize: serverQueryParamState.page_size,
+    pageCount,
+    itemCount,
+    setPageSize,
+  };
+
+  const searching: ISearchingActions<TParam> = {
+    searchText,
+    setSearchText,
+  };
+
+  function sortField(field: NormalizedField<ExtractKey<TParam, "order_by">>) {
+    setQueryParamState((current) => {
+      const ascendingField = current.order_by?.find((item) => item === field);
+      const descendingField = current.order_by?.find(
+        (item) => item === `-${field}`,
+      );
+
+      let result: (string & ExtractKey<TParam, "order_by">)[] | undefined = [];
+      if (descendingField) {
+        result = current.order_by?.filter((item) => item !== `-${field}`);
+      } else if (ascendingField) {
+        result = current.order_by?.filter((item) => item !== field);
+        result?.push(`-${field}` as string & ExtractKey<TParam, "order_by">);
+      } else {
+        result = current.order_by
+          ? [
+              ...current.order_by,
+              field as string & ExtractKey<TParam, "order_by">,
+            ]
+          : [field as string & ExtractKey<TParam, "order_by">];
+      }
+
+      return {
+        ...current,
+        order_by: result,
+        page: 1,
+      };
+    });
+  }
+
+  function getSortingDirection(
+    field: NormalizedField<ExtractKey<TParam, "order_by">>,
+  ) {
+    const invertedField = `-${field}`;
+    if (serverQueryParamState.order_by?.find((item) => item === field)) {
+      return "asc";
+    } else if (
+      serverQueryParamState.order_by?.find((item) => item === invertedField)
+    ) {
+      return "desc";
+    } else {
+      return undefined;
+    }
+  }
+
+  const sorting: ISortingActions<TParam> = {
+    sortField,
+    getSortingDirection,
+  };
+
+  function getFilterFieldValue(key: keyof TParam) {
+    // @ts-ignore correctly handle the keyof in the future
+    return queryParamState[key] as TParam[keyof TParam];
+  }
+
+  function setFilterFieldValue(key: keyof TParam) {
+    return (value: unknown) => {
+      setQueryParamState((current) => ({
+        ...current,
+        [key]: value,
+        page: 1,
+      }));
+    };
+  }
+
+  const filtering: IFilterActions<TParam> = {
+    getFilterFieldValue,
+    setFilterFieldValue,
+  };
+
+  const data =
+    options?.localCache && searchText
+      ? // @ts-ignore the results key is based on the interface returned. This will get sorted out in a future version
+        query.data?.results.filter((value: any) => {
+          if (options.localSearchFunction && searchText) {
+            if (searchText.includes(" ")) {
+              const searchWords = searchText.split(" ");
+              return searchWords.every((word) => {
+                if (options.localSearchFunction) {
+                  return options.localSearchFunction(word, value);
+                } else {
+                  return false;
+                }
+              });
+            } else {
+              return options.localSearchFunction(searchText, value);
+            }
+          } else {
+            return true;
+          }
+        })
+      : // @ts-ignore
+        query.data?.results;
+
+  return {
+    ...query,
+    raw: query.data,
+    data,
+    header: query.data?.headers,
+    pagination,
+    searching,
+    sorting,
+    filtering,
+  };
+}