@ventlio/tanstack-query 0.1.1 → 0.1.3

package/README.md

@@ -0,0 +1,3 @@
+# Ventlio/TanstackQuery
+
+## _Work on progress, we are building an HTTP request handler that uses tanstack-query_

package/dist/helpers/index.d.ts

@@ -0,0 +1 @@
+export declare const scrollToTop: () => void;

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 export * from './constants';
 export * from './request';
-export * from './useMyHook';

package/dist/index.js

@@ -6,7 +6,6 @@ var buildFormData = require('./request/buildFormData.js');
 var makeRequest = require('./request/make-request.js');
 var request_enum = require('./request/request.enum.js');
 var transformer = require('./request/transformer.js');
-var useMyHook = require('./useMyHook.js');
 
 
 
@@ -24,5 +23,4 @@ Object.defineProperty(exports, 'HttpMethod', {
 });
 exports.errorTransformer = transformer.errorTransformer;
 exports.successTransformer = transformer.successTransformer;
-exports.useMyHook = useMyHook.useMyHook;
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -1,5 +1,4 @@
 import axios from 'axios';
-import { useState } from 'react';
 
 const API_BASE_URL = '';
 
@@ -98,13 +97,5 @@ async function makeRequest({ body, method = HttpMethod.GET, path, bearerToken, f
     }
 }
 
-const useMyHook = () => {
-    const [value, setValue] = useState('');
-    const updateValue = (newValue) => {
-        setValue(newValue);
-    };
-    return [value, updateValue];
-};
-
-export { API_BASE_URL, ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, successTransformer, useMyHook };
+export { API_BASE_URL, ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, successTransformer };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/queries/index.d.ts

@@ -0,0 +1,4 @@
+export * from './useDeleteRequest';
+export * from './useGetRequest';
+export * from './usePatchRequest';
+export * from './usePostRequest';

package/dist/queries/queries.interface.d.ts

@@ -0,0 +1,8 @@
+export interface IPagination {
+    current_page: number;
+    next_page: number;
+    page_count: number;
+    previous_page: number;
+    size: number;
+    total: number;
+}

package/dist/queries/useDeleteRequest.d.ts

@@ -0,0 +1,115 @@
+import type { MutateOptions, QueryObserverResult } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request';
+export declare const useDeleteRequest: <TResponse>() => {
+    data: IRequestSuccess<TResponse>;
+    error: any;
+    isError: true;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+} | {
+    data: IRequestSuccess<TResponse>;
+    error: null;
+    isError: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+} | {
+    data: undefined;
+    error: any;
+    isError: true;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "loading";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+};

package/dist/queries/useGetRequest.d.ts

@@ -0,0 +1,139 @@
+import type { UseQueryOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request';
+export declare const useGetRequest: <TResponse extends Record<string, any>>({ path, load, queryOptions, }: {
+    path: string;
+    load?: boolean | undefined;
+    queryOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined;
+}) => {
+    updatePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    nextPage: () => void;
+    prevPage: () => void;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    gotoPage: (pageNumber: number) => void;
+    page: number;
+    queryKey: {}[];
+    data: IRequestSuccess<TResponse>;
+    error: any;
+    isError: true;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    updatePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    nextPage: () => void;
+    prevPage: () => void;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    gotoPage: (pageNumber: number) => void;
+    page: number;
+    queryKey: {}[];
+    data: IRequestSuccess<TResponse>;
+    error: null;
+    isError: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    updatePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    nextPage: () => void;
+    prevPage: () => void;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    gotoPage: (pageNumber: number) => void;
+    page: number;
+    queryKey: {}[];
+    data: undefined;
+    error: any;
+    isError: true;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    updatePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    nextPage: () => void;
+    prevPage: () => void;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    gotoPage: (pageNumber: number) => void;
+    page: number;
+    queryKey: {}[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "loading";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};

package/dist/queries/usePatchRequest.d.ts

@@ -0,0 +1,78 @@
+import type { MutateOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request/request.interface';
+export declare const usePatchRequest: <TResponse>({ path, formData, }: {
+    path: string;
+    formData?: boolean | undefined;
+}) => {
+    resetForm: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isLoading: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+} | {
+    resetForm: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: true;
+    isSuccess: false;
+    status: "loading";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+} | {
+    resetForm: boolean;
+    data: undefined;
+    error: IRequestError;
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+} | {
+    resetForm: boolean;
+    data: IRequestSuccess<TResponse>;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+};

package/dist/queries/usePostRequest.d.ts

@@ -0,0 +1,78 @@
+import type { MutateOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request';
+export declare const usePostRequest: <TResponse>({ path, formData, }: {
+    path: string;
+    formData?: boolean | undefined;
+}) => {
+    resetForm: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isLoading: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+} | {
+    resetForm: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: true;
+    isSuccess: false;
+    status: "loading";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+} | {
+    resetForm: boolean;
+    data: undefined;
+    error: IRequestError;
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+} | {
+    resetForm: boolean;
+    data: IRequestSuccess<TResponse>;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "license": "MIT",
   "main": "dist/index.js",
   "repository": {
@@ -62,11 +62,7 @@
     "typescript": "^4.9.5"
   },
   "files": [
-    "dist/app/*",
     "dist/**/*",
     "src"
-  ],
-  "dependencies": {
-    "rmf": "^2.0.0"
-  }
+  ]
 }

package/src/helpers/index.ts

@@ -0,0 +1,6 @@
+export const scrollToTop = () => {
+  window.scrollTo({
+    top: 0,
+    behavior: 'smooth',
+  });
+};

package/src/index.ts

@@ -1,3 +1,2 @@
 export * from './constants';
 export * from './request';
-export * from './useMyHook';

package/src/queries/index.ts

@@ -0,0 +1,4 @@
+export * from './useDeleteRequest';
+export * from './useGetRequest';
+export * from './usePatchRequest';
+export * from './usePostRequest';

package/src/queries/queries.interface.ts

@@ -0,0 +1,8 @@
+export interface IPagination {
+  current_page: number;
+  next_page: number;
+  page_count: number;
+  previous_page: number;
+  size: number;
+  total: number;
+}

package/src/queries/useDeleteRequest.ts

@@ -0,0 +1,52 @@
+import type { MutateOptions, QueryObserverResult } from '@tanstack/react-query';
+import { useQuery } from '@tanstack/react-query';
+import { useState } from 'react';
+import type { IRequestError, IRequestSuccess } from '../request';
+import { HttpMethod, makeRequest } from '../request';
+
+export const useDeleteRequest = <TResponse>() => {
+  const [requestPath, updateDeletePath] = useState<string>('');
+  const [options, setOptions] = useState<any>();
+  const authToken = '';
+  const query = useQuery<any, any, IRequestSuccess<TResponse>>(
+    [requestPath, {}],
+    () =>
+      new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) => {
+        setTimeout(async () => {
+          const postResponse = await makeRequest<TResponse>({
+            path: requestPath,
+            bearerToken: authToken,
+            method: HttpMethod.DELETE,
+          });
+          if (postResponse.status) {
+            res(postResponse as IRequestSuccess<TResponse>);
+          } else {
+            rej(postResponse);
+          }
+        }, 200);
+      }),
+    { ...options }
+  );
+
+  const updatedPathAsync = async (link: string) => {
+    return updateDeletePath(link);
+  };
+
+  const setOptionsAsync = async (fetchOptions: any) => {
+    return setOptions(fetchOptions);
+  };
+  const deleteR = async (
+    link: string,
+    fetchOptions?:
+      | MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown>
+      | undefined
+  ): Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>> => {
+    await updatedPathAsync(link);
+    await setOptionsAsync(fetchOptions);
+
+    return query.refetch<TResponse>({
+      queryKey: [link, {}],
+    });
+  };
+  return { updateDeletePath, deleteR, ...query };
+};

package/src/queries/useGetRequest.ts

@@ -0,0 +1,140 @@
+import type { UseQueryOptions } from '@tanstack/react-query';
+import { useQuery } from '@tanstack/react-query';
+import { startTransition, useState } from 'react';
+import type { IRequestError, IRequestSuccess } from '../request';
+import { makeRequest } from '../request';
+import type { IPagination } from './queries.interface';
+
+export const useGetRequest = <TResponse extends Record<string, any>>({
+  path,
+  load = false,
+  queryOptions,
+}: {
+  path: string;
+  load?: boolean;
+  queryOptions?: UseQueryOptions<
+    IRequestSuccess<TResponse | undefined>,
+    IRequestError,
+    IRequestSuccess<TResponse | undefined>,
+    Array<any>
+  >;
+}) => {
+  const [requestPath, updatePath] = useState<string>(path);
+  const authToken = '';
+  const [options, setOptions] = useState<any>(queryOptions);
+  const [page, setPage] = useState<number>(1);
+
+  const query = useQuery<any, any, IRequestSuccess<TResponse>>(
+    [requestPath, {}],
+    () =>
+      new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) => {
+        // work on removing this setTimeout, it was added to delay for the requestPath to be updated successfully
+        // could have used hook for this but will miss the purpose
+        setTimeout(async () => {
+          const postResponse = await makeRequest<TResponse>({
+            path: requestPath,
+            bearerToken: authToken,
+          });
+          if (postResponse.status) {
+            res(postResponse as IRequestSuccess<TResponse>);
+          } else {
+            rej(postResponse);
+          }
+        }, 200);
+      }),
+    {
+      enabled: load,
+      ...options,
+    }
+  );
+
+  const nextPage = () => {
+    if (query.data?.data.pagination) {
+      const pagination: IPagination = query.data.data.pagination;
+      if (
+        pagination.next_page !== pagination.current_page &&
+        pagination.next_page > pagination.current_page
+      ) {
+        updatePath(constructPaginationLink(requestPath, pagination.next_page));
+      }
+    }
+  };
+
+  const constructPaginationLink = (link: string, pageNumber: number) => {
+    const oldLink = link;
+    if (link.includes('?')) {
+      if (link.includes('?page=')) {
+        // replace current page number with new number
+        link = link.replace(/\?page=(\d+)/gim, `?page=${pageNumber}`);
+      } else if (link.includes('&page=')) {
+        link = link.replace(/&page=(\d+)/gim, `&page=${pageNumber}`);
+      } else {
+        link = `${link}&page=${pageNumber}`;
+      }
+    } else {
+      link = `${link}?page=${pageNumber}`;
+    }
+
+    // only update page when pagination is done
+    if (oldLink !== link) {
+      setPage(pageNumber);
+    }
+    return link;
+  };
+
+  const prevPage = () => {
+    if (query.data?.data.pagination) {
+      const pagination: IPagination = query.data.data.pagination;
+      if (
+        pagination.previous_page !== pagination.current_page &&
+        pagination.previous_page < pagination.current_page
+      ) {
+        updatePath(
+          constructPaginationLink(requestPath, pagination.previous_page)
+        );
+      }
+    }
+  };
+
+  const gotoPage = (pageNumber: number) => {
+    updatePath(constructPaginationLink(requestPath, pageNumber));
+  };
+
+  const updatedPathAsync = async (link: string) => {
+    startTransition(() => {
+      updatePath(link);
+    });
+  };
+
+  const setOptionsAsync = async (fetchOptions: any) => {
+    startTransition(() => {
+      setOptions(fetchOptions);
+    });
+  };
+
+  const get = async (
+    link: string,
+    fetchOptions?: UseQueryOptions<
+      IRequestSuccess<TResponse | undefined>,
+      IRequestError,
+      IRequestSuccess<TResponse | undefined>,
+      Array<any>
+    >
+  ): Promise<IRequestSuccess<TResponse> | undefined> => {
+    await setOptionsAsync(fetchOptions);
+    await updatedPathAsync(link);
+
+    return query.data;
+  };
+
+  return {
+    ...query,
+    updatePath,
+    nextPage,
+    prevPage,
+    get,
+    gotoPage,
+    page,
+    queryKey: [requestPath, {}],
+  };
+};

package/src/queries/usePatchRequest.ts

@@ -0,0 +1,61 @@
+import type { MutateOptions } from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
+import { useState } from 'react';
+import { scrollToTop } from '../helpers';
+import { HttpMethod, makeRequest } from '../request';
+
+import type {
+  IRequestError,
+  IRequestSuccess,
+} from '../request/request.interface';
+
+export const usePatchRequest = <TResponse>({
+  path,
+  formData = false,
+}: {
+  path: string;
+  formData?: boolean;
+}) => {
+  const authToken = '';
+  const [resetForm, setResetForm] = useState<boolean>(false);
+
+  // register post mutation
+  const mutation = useMutation<IRequestSuccess<TResponse>, IRequestError>(
+    (postData: any) =>
+      new Promise<IRequestSuccess<TResponse>>((res, rej) => {
+        setResetForm(false);
+
+        makeRequest<TResponse>({
+          path: path,
+          body: postData,
+          method: HttpMethod.PATCH,
+          bearerToken: authToken,
+          formData,
+        }).then((postResponse) => {
+          if (postResponse.status) {
+            setResetForm(true);
+            // scroll to top after success
+            scrollToTop();
+            res(postResponse as IRequestSuccess<TResponse>);
+          } else {
+            // scroll to top after error
+            window.scrollTo({
+              top: 0,
+              behavior: 'smooth',
+            });
+            rej(postResponse);
+          }
+        });
+      })
+  );
+  const patch = async (
+    postData: any,
+    options?:
+      | MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown>
+      | undefined
+  ): Promise<IRequestSuccess<TResponse>> => {
+    return mutation.mutateAsync(postData, options);
+  };
+
+  return { patch, ...mutation, resetForm };
+};

package/src/queries/usePostRequest.ts

@@ -0,0 +1,59 @@
+import type { MutateOptions } from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
+import { useState } from 'react';
+import type { IRequestError, IRequestSuccess } from '../request';
+import { HttpMethod, makeRequest } from '../request';
+
+export const usePostRequest = <TResponse>({
+  path,
+  formData = false,
+}: {
+  path: string;
+  formData?: boolean;
+}) => {
+  const authToken = '';
+
+  const [resetForm, setResetForm] = useState<boolean>(false);
+
+  // register post mutation
+  const mutation = useMutation<IRequestSuccess<TResponse>, IRequestError>(
+    async (postData: any) =>
+      new Promise<IRequestSuccess<TResponse>>((res, rej) => {
+        setResetForm(false);
+        makeRequest<TResponse>({
+          path: path,
+          body: postData,
+          method: HttpMethod.POST,
+          bearerToken: authToken,
+          formData,
+        }).then((postResponse) => {
+          if (postResponse.status) {
+            setResetForm(true);
+            // scroll to top after success
+            window.scrollTo({
+              top: 0,
+              behavior: 'smooth',
+            });
+            res(postResponse as IRequestSuccess<TResponse>);
+          } else {
+            // scroll to top after error
+            window.scrollTo({
+              top: 0,
+              behavior: 'smooth',
+            });
+            rej(postResponse);
+          }
+        });
+      })
+  );
+  const post = async (
+    postData: any,
+    options?:
+      | MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown>
+      | undefined
+  ): Promise<IRequestSuccess<TResponse>> => {
+    return mutation.mutateAsync(postData, options);
+  };
+
+  return { post, ...mutation, resetForm };
+};

package/dist/useMyHook.d.ts

@@ -1 +0,0 @@
-export declare const useMyHook: () => [string, (newValue: string) => void];

package/dist/useMyHook.js

@@ -1,14 +0,0 @@
-'use strict';
-
-var react = require('react');
-
-const useMyHook = () => {
-    const [value, setValue] = react.useState('');
-    const updateValue = (newValue) => {
-        setValue(newValue);
-    };
-    return [value, updateValue];
-};
-
-exports.useMyHook = useMyHook;
-//# sourceMappingURL=useMyHook.js.map

package/dist/useMyHook.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useMyHook.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/src/useMyHook.ts

@@ -1,11 +0,0 @@
-import { useState } from 'react';
-
-export const useMyHook = (): [string, (newValue: string) => void] => {
-  const [value, setValue] = useState('');
-
-  const updateValue = (newValue: string) => {
-    setValue(newValue);
-  };
-
-  return [value, updateValue];
-};