From 8e7ecc8df18576d7a26404671db2d1a70c0e4108 Mon Sep 17 00:00:00 2001 From: Damian Osipiuk Date: Wed, 23 Feb 2022 00:07:13 +0100 Subject: [PATCH 1/6] feat: unref wrappers for QueryClient, QueryCache and MutationCache --- src/vue/mutationCache.ts | 21 +++++++++++++++++++++ src/vue/queryCache.ts | 22 ++++++++++++++++++++++ src/vue/types.ts | 8 ++++++++ 3 files changed, 51 insertions(+) create mode 100644 src/vue/mutationCache.ts create mode 100644 src/vue/queryCache.ts diff --git a/src/vue/mutationCache.ts b/src/vue/mutationCache.ts new file mode 100644 index 0000000..21a75da --- /dev/null +++ b/src/vue/mutationCache.ts @@ -0,0 +1,21 @@ +import { MutationCache as MC } from "react-query/core"; +import type { Mutation } from "react-query/core"; +import type { MutationFilters } from "react-query/types/core/utils"; +import type { MaybeRef, MaybeRefParams } from "./types"; +import { cloneDeepUnref } from "./utils"; + +export class MutationCache extends MC { + constructor(config?: MaybeRef) { + super(cloneDeepUnref(config)); + } + + find( + filters: MaybeRef + ): Mutation | undefined { + return super.find(cloneDeepUnref(filters)); + } + + findAll: MaybeRefParams = (filters) => { + return super.findAll(cloneDeepUnref(filters)); + }; +} diff --git a/src/vue/queryCache.ts b/src/vue/queryCache.ts new file mode 100644 index 0000000..78d4d18 --- /dev/null +++ b/src/vue/queryCache.ts @@ -0,0 +1,22 @@ +import { QueryCache as QC } from "react-query/core"; +import type { Query, QueryKey } from "react-query/core"; +import type { QueryFilters } from "react-query/types/core/utils"; +import type { MaybeRef, MaybeRefParams } from "./types"; +import { cloneDeepUnref } from "./utils"; + +export class QueryCache extends QC { + constructor(config?: MaybeRef) { + super(cloneDeepUnref(config)); + } + + find( + arg1: MaybeRef, + arg2?: MaybeRef + ): Query | undefined { + return super.find(cloneDeepUnref(arg1), cloneDeepUnref(arg2)); + } + + findAll: MaybeRefParams = (arg1, arg2) => { + return super.findAll(cloneDeepUnref(arg1), cloneDeepUnref(arg2)); + }; +} diff --git a/src/vue/types.ts b/src/vue/types.ts index d483849..b35f492 100644 --- a/src/vue/types.ts +++ b/src/vue/types.ts @@ -7,6 +7,14 @@ import { Ref } from "vue-demi"; export type MaybeRef = Ref | T; +export type MaybeRefConverter = { + [K in keyof TParams]: MaybeRef; +}; + +export type MaybeRefParams = F extends (...args: infer T) => infer R + ? (...args: MaybeRefConverter) => R + : never; + export type WithQueryClientKey = T & { queryClientKey?: string }; // A Vue version of QueriesObserverOptions from "react-query/types/core" From 92691d78d2640ef87353403d6083e7780b172f6a Mon Sep 17 00:00:00 2001 From: Damian Osipiuk Date: Fri, 11 Mar 2022 23:37:43 +0100 Subject: [PATCH 2/6] feat: export wrappers --- src/index.ts | 3 --- src/vue/index.ts | 3 +++ src/vue/mutationCache.ts | 6 +++--- src/vue/queryCache.ts | 26 +++++++++++++++++++++----- src/vue/types.ts | 8 -------- 5 files changed, 27 insertions(+), 19 deletions(-) diff --git a/src/index.ts b/src/index.ts index 780dcb1..0b7803b 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,13 +1,10 @@ /* istanbul ignore file */ export { - QueryClient, QueryObserver, QueriesObserver, InfiniteQueryObserver, MutationObserver, - QueryCache, - MutationCache, hydrate, dehydrate, focusManager, diff --git a/src/vue/index.ts b/src/vue/index.ts index f5e23be..d253768 100644 --- a/src/vue/index.ts +++ b/src/vue/index.ts @@ -4,6 +4,9 @@ export { useQueryClient } from "./useQueryClient"; export { useQueryProvider } from "./useQueryProvider"; export { VueQueryPlugin } from "./vueQueryPlugin"; +export { QueryClient } from "./queryClient"; +export { QueryCache } from "./queryCache"; +export { MutationCache } from "./mutationCache"; export { useQuery } from "./useQuery"; export { useQueries } from "./useQueries"; export { useInfiniteQuery } from "./useInfiniteQuery"; diff --git a/src/vue/mutationCache.ts b/src/vue/mutationCache.ts index 21a75da..361d8a3 100644 --- a/src/vue/mutationCache.ts +++ b/src/vue/mutationCache.ts @@ -1,7 +1,7 @@ import { MutationCache as MC } from "react-query/core"; import type { Mutation } from "react-query/core"; import type { MutationFilters } from "react-query/types/core/utils"; -import type { MaybeRef, MaybeRefParams } from "./types"; +import type { MaybeRef } from "./types"; import { cloneDeepUnref } from "./utils"; export class MutationCache extends MC { @@ -15,7 +15,7 @@ export class MutationCache extends MC { return super.find(cloneDeepUnref(filters)); } - findAll: MaybeRefParams = (filters) => { + findAll(filters: MaybeRef): Mutation[] { return super.findAll(cloneDeepUnref(filters)); - }; + } } diff --git a/src/vue/queryCache.ts b/src/vue/queryCache.ts index 78d4d18..48826e3 100644 --- a/src/vue/queryCache.ts +++ b/src/vue/queryCache.ts @@ -1,8 +1,8 @@ import { QueryCache as QC } from "react-query/core"; import type { Query, QueryKey } from "react-query/core"; import type { QueryFilters } from "react-query/types/core/utils"; -import type { MaybeRef, MaybeRefParams } from "./types"; -import { cloneDeepUnref } from "./utils"; +import type { MaybeRef } from "./types"; +import { cloneDeepUnref, isQueryKey } from "./utils"; export class QueryCache extends QC { constructor(config?: MaybeRef) { @@ -16,7 +16,23 @@ export class QueryCache extends QC { return super.find(cloneDeepUnref(arg1), cloneDeepUnref(arg2)); } - findAll: MaybeRefParams = (arg1, arg2) => { - return super.findAll(cloneDeepUnref(arg1), cloneDeepUnref(arg2)); - }; + findAll( + queryKey?: MaybeRef, + filters?: MaybeRef + ): Query[]; + findAll(filters?: MaybeRef): Query[]; + findAll( + arg1?: MaybeRef, + arg2?: MaybeRef + ): Query[]; + findAll( + arg1?: MaybeRef, + arg2?: MaybeRef + ): Query[] { + const arg1Unreffed = cloneDeepUnref(arg1); + if (isQueryKey(arg1Unreffed)) { + return super.findAll(arg1Unreffed, cloneDeepUnref(arg2)); + } + return super.findAll(arg1Unreffed); + } } diff --git a/src/vue/types.ts b/src/vue/types.ts index b35f492..d483849 100644 --- a/src/vue/types.ts +++ b/src/vue/types.ts @@ -7,14 +7,6 @@ import { Ref } from "vue-demi"; export type MaybeRef = Ref | T; -export type MaybeRefConverter = { - [K in keyof TParams]: MaybeRef; -}; - -export type MaybeRefParams = F extends (...args: infer T) => infer R - ? (...args: MaybeRefConverter) => R - : never; - export type WithQueryClientKey = T & { queryClientKey?: string }; // A Vue version of QueriesObserverOptions from "react-query/types/core" From f97aadf59ff51b59973a8a54acaa502f2482f769 Mon Sep 17 00:00:00 2001 From: Damian Osipiuk Date: Sun, 13 Mar 2022 16:15:27 +0100 Subject: [PATCH 3/6] feat: queryClient wrapper --- src/vue/queryClient.ts | 545 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 545 insertions(+) create mode 100644 src/vue/queryClient.ts diff --git a/src/vue/queryClient.ts b/src/vue/queryClient.ts new file mode 100644 index 0000000..d02b4c6 --- /dev/null +++ b/src/vue/queryClient.ts @@ -0,0 +1,545 @@ +import { isRef } from "vue-demi"; +import { QueryClient as QC } from "react-query/core"; +import type { + QueryKey, + QueryClientConfig, + SetDataOptions, + ResetQueryFilters, + ResetOptions, + CancelOptions, + InvalidateQueryFilters, + InvalidateOptions, + RefetchQueryFilters, + RefetchOptions, + FetchQueryOptions, + QueryFunction, + FetchInfiniteQueryOptions, + InfiniteData, + DefaultOptions, + QueryObserverOptions, + MutationKey, + MutationObserverOptions, +} from "react-query/core"; +import type { + QueryFilters, + MutationFilters, + Updater, +} from "react-query/types/core/utils"; +import type { QueryState } from "react-query/types/core/query"; +import type { MaybeRef } from "./types"; +import { cloneDeepUnref, isQueryKey } from "./utils"; +import { QueryCache } from "./queryCache"; +import { MutationCache } from "./mutationCache"; + +export class QueryClient extends QC { + constructor(config: MaybeRef = {}) { + const unreffedConfig = isRef(config) ? config.value : config; + const vueQueryConfig: QueryClientConfig = { + defaultOptions: cloneDeepUnref(unreffedConfig.defaultOptions), + queryCache: unreffedConfig.queryCache || new QueryCache(), + mutationCache: unreffedConfig.mutationCache || new MutationCache(), + }; + super(vueQueryConfig); + } + + isFetching(filters?: MaybeRef): number; + isFetching( + queryKey?: MaybeRef, + filters?: MaybeRef + ): number; + isFetching( + arg1?: MaybeRef, + arg2?: MaybeRef + ): number { + const arg1Unreffed = cloneDeepUnref(arg1); + if (isQueryKey(arg1Unreffed)) { + return super.isFetching(arg1Unreffed, cloneDeepUnref(arg2)); + } + return super.isFetching(arg1Unreffed); + } + + isMutating(filters?: MaybeRef): number { + return super.isMutating(cloneDeepUnref(filters)); + } + + getQueryData( + queryKey: MaybeRef, + filters?: MaybeRef + ): TData | undefined { + return super.getQueryData( + cloneDeepUnref(queryKey), + cloneDeepUnref(filters) + ); + } + + getQueriesData( + queryKey: MaybeRef + ): [QueryKey, TData][]; + getQueriesData( + filters: MaybeRef + ): [QueryKey, TData][]; + getQueriesData( + queryKeyOrFilters: MaybeRef | MaybeRef + ): [QueryKey, TData][] { + const unreffed = cloneDeepUnref(queryKeyOrFilters); + if (isQueryKey(unreffed)) { + return super.getQueriesData(unreffed); + } + return super.getQueriesData(unreffed); + } + + setQueryData( + queryKey: MaybeRef, + updater: Updater, + options?: MaybeRef + ): TData { + return super.setQueryData( + cloneDeepUnref(queryKey), + updater, + cloneDeepUnref(options) + ); + } + + setQueriesData( + queryKey: MaybeRef, + updater: Updater, + options?: MaybeRef + ): [QueryKey, TData][]; + setQueriesData( + filters: MaybeRef, + updater: Updater, + options?: MaybeRef + ): [QueryKey, TData][]; + setQueriesData( + queryKeyOrFilters: MaybeRef, + updater: Updater, + options?: MaybeRef + ): [QueryKey, TData][] { + const arg1Unreffed = cloneDeepUnref(queryKeyOrFilters); + if (isQueryKey(arg1Unreffed)) { + return super.setQueriesData( + arg1Unreffed, + updater, + cloneDeepUnref(options) + ); + } + return super.setQueriesData(arg1Unreffed, updater, cloneDeepUnref(options)); + } + + getQueryState( + queryKey: MaybeRef, + filters?: MaybeRef + ): QueryState | undefined { + return super.getQueryState( + cloneDeepUnref(queryKey), + cloneDeepUnref(filters) + ); + } + + removeQueries(filters?: MaybeRef): void; + removeQueries( + queryKey?: MaybeRef, + filters?: MaybeRef + ): void; + removeQueries( + arg1?: MaybeRef, + arg2?: MaybeRef + ): void { + const arg1Unreffed = cloneDeepUnref(arg1); + if (isQueryKey(arg1Unreffed)) { + return super.removeQueries(arg1Unreffed, cloneDeepUnref(arg2)); + } + return super.removeQueries(arg1Unreffed); + } + + resetQueries( + filters?: MaybeRef>, + options?: MaybeRef + ): Promise; + resetQueries( + queryKey?: MaybeRef, + filters?: MaybeRef>, + options?: MaybeRef + ): Promise; + resetQueries( + arg1?: MaybeRef>, + arg2?: MaybeRef | ResetOptions>, + arg3?: MaybeRef + ): Promise { + const arg1Unreffed = cloneDeepUnref(arg1); + const arg2Unreffed = cloneDeepUnref(arg2); + if (isQueryKey(arg1Unreffed)) { + return super.resetQueries( + arg1Unreffed, + arg2Unreffed as ResetQueryFilters | undefined, + cloneDeepUnref(arg3) + ); + } + return super.resetQueries(arg1Unreffed, arg2Unreffed as ResetOptions); + } + + cancelQueries( + filters?: MaybeRef, + options?: MaybeRef + ): Promise; + cancelQueries( + queryKey?: MaybeRef, + filters?: MaybeRef, + options?: MaybeRef + ): Promise; + cancelQueries( + arg1?: MaybeRef, + arg2?: MaybeRef, + arg3?: MaybeRef + ): Promise { + const arg1Unreffed = cloneDeepUnref(arg1); + const arg2Unreffed = cloneDeepUnref(arg2); + if (isQueryKey(arg1Unreffed)) { + return super.cancelQueries( + arg1Unreffed, + arg2Unreffed as QueryFilters | undefined, + cloneDeepUnref(arg3) + ); + } + return super.cancelQueries(arg1Unreffed, arg2Unreffed as CancelOptions); + } + + invalidateQueries( + filters?: MaybeRef>, + options?: MaybeRef + ): Promise; + invalidateQueries( + queryKey?: MaybeRef, + filters?: MaybeRef>, + options?: MaybeRef + ): Promise; + invalidateQueries( + arg1?: MaybeRef>, + arg2?: MaybeRef | InvalidateOptions>, + arg3?: MaybeRef + ): Promise { + const arg1Unreffed = cloneDeepUnref(arg1); + const arg2Unreffed = cloneDeepUnref(arg2); + if (isQueryKey(arg1Unreffed)) { + return super.invalidateQueries( + arg1Unreffed, + arg2Unreffed as InvalidateQueryFilters | undefined, + cloneDeepUnref(arg3) + ); + } + return super.invalidateQueries( + arg1Unreffed, + arg2Unreffed as InvalidateOptions + ); + } + + refetchQueries( + filters?: MaybeRef>, + options?: MaybeRef + ): Promise; + refetchQueries( + queryKey?: MaybeRef, + filters?: MaybeRef>, + options?: MaybeRef + ): Promise; + refetchQueries( + arg1?: MaybeRef>, + arg2?: MaybeRef | RefetchOptions>, + arg3?: MaybeRef + ): Promise { + const arg1Unreffed = cloneDeepUnref(arg1); + const arg2Unreffed = cloneDeepUnref(arg2); + if (isQueryKey(arg1Unreffed)) { + return super.refetchQueries( + arg1Unreffed, + arg2Unreffed as RefetchQueryFilters | undefined, + cloneDeepUnref(arg3) + ); + } + return super.refetchQueries(arg1Unreffed, arg2Unreffed as RefetchOptions); + } + + fetchQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + options: MaybeRef> + ): Promise; + fetchQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + queryKey: MaybeRef, + options?: MaybeRef< + FetchQueryOptions + > + ): Promise; + fetchQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + queryKey: MaybeRef, + queryFn: QueryFunction, + options?: MaybeRef< + FetchQueryOptions + > + ): Promise; + fetchQuery< + TQueryFnData, + TError, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + arg1: + | MaybeRef + | MaybeRef>, + arg2?: + | QueryFunction + | MaybeRef>, + arg3?: MaybeRef> + ): Promise { + const arg1Unreffed = cloneDeepUnref(arg1); + const arg2Unreffed = cloneDeepUnref(arg2); + if (isQueryKey(arg1Unreffed)) { + return super.fetchQuery( + arg1Unreffed as TQueryKey, + arg2Unreffed as QueryFunction, + cloneDeepUnref(arg3) as FetchQueryOptions< + TQueryFnData, + TError, + TData, + TQueryKey + > + ); + } + return super.fetchQuery( + arg1Unreffed as FetchQueryOptions + ); + } + + prefetchQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + options: MaybeRef> + ): Promise; + prefetchQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + queryKey: MaybeRef, + options?: MaybeRef< + FetchQueryOptions + > + ): Promise; + prefetchQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + queryKey: MaybeRef, + queryFn: QueryFunction, + options?: MaybeRef< + FetchQueryOptions + > + ): Promise; + prefetchQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + arg1: MaybeRef< + TQueryKey | FetchQueryOptions + >, + arg2?: + | QueryFunction + | MaybeRef>, + arg3?: MaybeRef> + ): Promise { + return super.prefetchQuery( + cloneDeepUnref(arg1) as any, + cloneDeepUnref(arg2) as any, + cloneDeepUnref(arg3) as any + ); + } + + fetchInfiniteQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + options: MaybeRef< + FetchInfiniteQueryOptions + > + ): Promise>; + fetchInfiniteQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + queryKey: MaybeRef, + options?: MaybeRef< + FetchInfiniteQueryOptions + > + ): Promise>; + fetchInfiniteQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + queryKey: MaybeRef, + queryFn: QueryFunction, + options?: MaybeRef< + FetchInfiniteQueryOptions + > + ): Promise>; + fetchInfiniteQuery< + TQueryFnData, + TError, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + arg1: MaybeRef< + | TQueryKey + | FetchInfiniteQueryOptions + >, + arg2?: + | QueryFunction + | MaybeRef< + FetchInfiniteQueryOptions + >, + arg3?: MaybeRef< + FetchInfiniteQueryOptions + > + ): Promise> { + const arg1Unreffed = cloneDeepUnref(arg1); + const arg2Unreffed = cloneDeepUnref(arg2); + if (isQueryKey(arg1Unreffed)) { + return super.fetchInfiniteQuery( + arg1Unreffed as TQueryKey, + arg2Unreffed as QueryFunction, + cloneDeepUnref(arg3) as FetchInfiniteQueryOptions< + TQueryFnData, + TError, + TData, + TQueryKey + > + ); + } + return super.fetchInfiniteQuery( + arg1Unreffed as FetchInfiniteQueryOptions< + TQueryFnData, + TError, + TData, + TQueryKey + > + ); + } + + prefetchInfiniteQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + options: MaybeRef< + FetchInfiniteQueryOptions + > + ): Promise; + prefetchInfiniteQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + queryKey: MaybeRef, + options?: MaybeRef< + FetchInfiniteQueryOptions + > + ): Promise; + prefetchInfiniteQuery< + TQueryFnData = unknown, + TError = unknown, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + queryKey: MaybeRef, + queryFn: QueryFunction, + options?: MaybeRef< + FetchInfiniteQueryOptions + > + ): Promise; + prefetchInfiniteQuery< + TQueryFnData, + TError, + TData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey + >( + arg1: MaybeRef< + | TQueryKey + | FetchInfiniteQueryOptions + >, + arg2?: + | QueryFunction + | MaybeRef< + FetchInfiniteQueryOptions + >, + arg3?: MaybeRef< + FetchInfiniteQueryOptions + > + ): Promise { + return super.prefetchInfiniteQuery( + cloneDeepUnref(arg1) as any, + cloneDeepUnref(arg2) as any, + cloneDeepUnref(arg3) as any + ); + } + + setDefaultOptions(options: MaybeRef): void { + super.setDefaultOptions(cloneDeepUnref(options)); + } + + setQueryDefaults( + queryKey: MaybeRef, + options: MaybeRef> + ): void { + super.setQueryDefaults(cloneDeepUnref(queryKey), cloneDeepUnref(options)); + } + + getQueryDefaults( + queryKey?: MaybeRef + ): QueryObserverOptions | undefined { + return super.getQueryDefaults(cloneDeepUnref(queryKey)); + } + + setMutationDefaults( + mutationKey: MaybeRef, + options: MaybeRef> + ): void { + super.setMutationDefaults( + cloneDeepUnref(mutationKey), + cloneDeepUnref(options) + ); + } + + getMutationDefaults( + mutationKey?: MaybeRef + ): MutationObserverOptions | undefined { + return super.getMutationDefaults(cloneDeepUnref(mutationKey)); + } +} From 4b637e67609e45562a653382f33ad01716b9833d Mon Sep 17 00:00:00 2001 From: Damian Osipiuk Date: Thu, 17 Mar 2022 00:00:01 +0100 Subject: [PATCH 4/6] test: tests for QueryCache and MutationCache --- src/vue/__tests__/mutationCache.test.ts | 44 +++++++++++++++++++ src/vue/__tests__/queryCache.test.ts | 58 +++++++++++++++++++++++++ src/vue/mutationCache.ts | 10 ++--- src/vue/queryCache.ts | 24 +++++----- src/vue/types.ts | 7 +++ 5 files changed, 122 insertions(+), 21 deletions(-) create mode 100644 src/vue/__tests__/mutationCache.test.ts create mode 100644 src/vue/__tests__/queryCache.test.ts diff --git a/src/vue/__tests__/mutationCache.test.ts b/src/vue/__tests__/mutationCache.test.ts new file mode 100644 index 0000000..4c3746c --- /dev/null +++ b/src/vue/__tests__/mutationCache.test.ts @@ -0,0 +1,44 @@ +import { ref } from "vue-demi"; +import { MutationCache as MutationCacheOrigin } from "react-query/core"; + +import { MutationCache } from "../mutationCache"; + +describe("MutationCache", () => { + beforeAll(() => { + jest.spyOn(MutationCacheOrigin.prototype, "find"); + jest.spyOn(MutationCacheOrigin.prototype, "findAll"); + }); + + beforeEach(() => { + jest.clearAllMocks(); + }); + + describe("find", () => { + test("should properly unwrap parameters", async () => { + const mutationCache = new MutationCache(); + + mutationCache.find({ + mutationKey: ref("baz"), + }); + + expect(MutationCacheOrigin.prototype.find).toBeCalledWith({ + exact: true, + mutationKey: "baz", + }); + }); + }); + + describe("findAll", () => { + test("should properly unwrap parameters", async () => { + const mutationCache = new MutationCache(); + + mutationCache.findAll({ + mutationKey: ref("baz"), + }); + + expect(MutationCacheOrigin.prototype.findAll).toBeCalledWith({ + mutationKey: "baz", + }); + }); + }); +}); diff --git a/src/vue/__tests__/queryCache.test.ts b/src/vue/__tests__/queryCache.test.ts new file mode 100644 index 0000000..b824ba7 --- /dev/null +++ b/src/vue/__tests__/queryCache.test.ts @@ -0,0 +1,58 @@ +import { ref } from "vue-demi"; +import { QueryCache as QueryCacheOrigin } from "react-query/core"; + +import { QueryCache } from "../queryCache"; + +describe("QueryCache", () => { + beforeAll(() => { + jest.spyOn(QueryCacheOrigin.prototype, "find"); + jest.spyOn(QueryCacheOrigin.prototype, "findAll"); + }); + + beforeEach(() => { + jest.clearAllMocks(); + }); + + describe("find", () => { + test("should properly unwrap parameters", async () => { + const queryCache = new QueryCache(); + + queryCache.find(["foo", ref("bar")], { + queryKey: ref("baz"), + }); + + expect(QueryCacheOrigin.prototype.find).toBeCalledWith(["foo", "bar"], { + queryKey: "baz", + }); + }); + }); + + describe("findAll", () => { + test("should properly unwrap two parameters", async () => { + const queryCache = new QueryCache(); + + queryCache.findAll(["foo", ref("bar")], { + queryKey: ref("baz"), + }); + + expect(QueryCacheOrigin.prototype.findAll).toBeCalledWith( + ["foo", "bar"], + { + queryKey: "bsaz", + } + ); + }); + + test("should properly unwrap one parameter", async () => { + const queryCache = new QueryCache(); + + queryCache.findAll({ + queryKey: ref("baz"), + }); + + expect(QueryCacheOrigin.prototype.findAll).toBeCalledWith({ + queryKey: "baz", + }); + }); + }); +}); diff --git a/src/vue/mutationCache.ts b/src/vue/mutationCache.ts index 361d8a3..dae5111 100644 --- a/src/vue/mutationCache.ts +++ b/src/vue/mutationCache.ts @@ -1,21 +1,17 @@ import { MutationCache as MC } from "react-query/core"; import type { Mutation } from "react-query/core"; import type { MutationFilters } from "react-query/types/core/utils"; -import type { MaybeRef } from "./types"; +import type { MaybeRefDeep } from "./types"; import { cloneDeepUnref } from "./utils"; export class MutationCache extends MC { - constructor(config?: MaybeRef) { - super(cloneDeepUnref(config)); - } - find( - filters: MaybeRef + filters: MaybeRefDeep ): Mutation | undefined { return super.find(cloneDeepUnref(filters)); } - findAll(filters: MaybeRef): Mutation[] { + findAll(filters: MaybeRefDeep): Mutation[] { return super.findAll(cloneDeepUnref(filters)); } } diff --git a/src/vue/queryCache.ts b/src/vue/queryCache.ts index 48826e3..b06d67f 100644 --- a/src/vue/queryCache.ts +++ b/src/vue/queryCache.ts @@ -1,33 +1,29 @@ import { QueryCache as QC } from "react-query/core"; import type { Query, QueryKey } from "react-query/core"; import type { QueryFilters } from "react-query/types/core/utils"; -import type { MaybeRef } from "./types"; +import type { MaybeRefDeep } from "./types"; import { cloneDeepUnref, isQueryKey } from "./utils"; export class QueryCache extends QC { - constructor(config?: MaybeRef) { - super(cloneDeepUnref(config)); - } - find( - arg1: MaybeRef, - arg2?: MaybeRef + arg1: MaybeRefDeep, + arg2?: MaybeRefDeep ): Query | undefined { return super.find(cloneDeepUnref(arg1), cloneDeepUnref(arg2)); } findAll( - queryKey?: MaybeRef, - filters?: MaybeRef + queryKey?: MaybeRefDeep, + filters?: MaybeRefDeep ): Query[]; - findAll(filters?: MaybeRef): Query[]; + findAll(filters?: MaybeRefDeep): Query[]; findAll( - arg1?: MaybeRef, - arg2?: MaybeRef + arg1?: MaybeRefDeep, + arg2?: MaybeRefDeep ): Query[]; findAll( - arg1?: MaybeRef, - arg2?: MaybeRef + arg1?: MaybeRefDeep, + arg2?: MaybeRefDeep ): Query[] { const arg1Unreffed = cloneDeepUnref(arg1); if (isQueryKey(arg1Unreffed)) { diff --git a/src/vue/types.ts b/src/vue/types.ts index d483849..196a95d 100644 --- a/src/vue/types.ts +++ b/src/vue/types.ts @@ -6,6 +6,13 @@ import type { import { Ref } from "vue-demi"; export type MaybeRef = Ref | T; +export type MaybeRefDeep = MaybeRef< + T extends object + ? { + [Property in keyof T]: MaybeRef; + } + : T +>; export type WithQueryClientKey = T & { queryClientKey?: string }; From 0b3ead02897a5d591456899000a717f212b1ff5c Mon Sep 17 00:00:00 2001 From: Damian Osipiuk Date: Thu, 17 Mar 2022 00:17:21 +0100 Subject: [PATCH 5/6] fix: types --- src/vue/__tests__/queryCache.test.ts | 2 +- src/vue/mutationCache.ts | 4 ++-- src/vue/queryCache.ts | 11 +++++++---- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/src/vue/__tests__/queryCache.test.ts b/src/vue/__tests__/queryCache.test.ts index b824ba7..2df7b29 100644 --- a/src/vue/__tests__/queryCache.test.ts +++ b/src/vue/__tests__/queryCache.test.ts @@ -38,7 +38,7 @@ describe("QueryCache", () => { expect(QueryCacheOrigin.prototype.findAll).toBeCalledWith( ["foo", "bar"], { - queryKey: "bsaz", + queryKey: "baz", } ); }); diff --git a/src/vue/mutationCache.ts b/src/vue/mutationCache.ts index dae5111..48cbd29 100644 --- a/src/vue/mutationCache.ts +++ b/src/vue/mutationCache.ts @@ -8,10 +8,10 @@ export class MutationCache extends MC { find( filters: MaybeRefDeep ): Mutation | undefined { - return super.find(cloneDeepUnref(filters)); + return super.find(cloneDeepUnref(filters) as MutationFilters); } findAll(filters: MaybeRefDeep): Mutation[] { - return super.findAll(cloneDeepUnref(filters)); + return super.findAll(cloneDeepUnref(filters) as MutationFilters); } } diff --git a/src/vue/queryCache.ts b/src/vue/queryCache.ts index b06d67f..2d4556a 100644 --- a/src/vue/queryCache.ts +++ b/src/vue/queryCache.ts @@ -9,7 +9,9 @@ export class QueryCache extends QC { arg1: MaybeRefDeep, arg2?: MaybeRefDeep ): Query | undefined { - return super.find(cloneDeepUnref(arg1), cloneDeepUnref(arg2)); + const arg1Unreffed = cloneDeepUnref(arg1); + const arg2Unreffed = cloneDeepUnref(arg2) as QueryFilters; + return super.find(arg1Unreffed, arg2Unreffed); } findAll( @@ -22,12 +24,13 @@ export class QueryCache extends QC { arg2?: MaybeRefDeep ): Query[]; findAll( - arg1?: MaybeRefDeep, + arg1?: MaybeRefDeep | MaybeRefDeep, arg2?: MaybeRefDeep ): Query[] { - const arg1Unreffed = cloneDeepUnref(arg1); + const arg1Unreffed = cloneDeepUnref(arg1) as QueryKey | QueryFilters; + const arg2Unreffed = cloneDeepUnref(arg2) as QueryFilters; if (isQueryKey(arg1Unreffed)) { - return super.findAll(arg1Unreffed, cloneDeepUnref(arg2)); + return super.findAll(arg1Unreffed, arg2Unreffed); } return super.findAll(arg1Unreffed); } From 9655d8ea6cf7f623e7b2be9be149602b2e936463 Mon Sep 17 00:00:00 2001 From: Damian Osipiuk Date: Fri, 18 Mar 2022 23:42:10 +0100 Subject: [PATCH 6/6] test: queryClient --- src/vue/__tests__/queryClient.test.ts | 550 ++++++++++++++++++++++++++ src/vue/queryClient.ts | 280 +++++++------ src/vue/types.ts | 2 +- 3 files changed, 703 insertions(+), 129 deletions(-) create mode 100644 src/vue/__tests__/queryClient.test.ts diff --git a/src/vue/__tests__/queryClient.test.ts b/src/vue/__tests__/queryClient.test.ts new file mode 100644 index 0000000..d1b04e5 --- /dev/null +++ b/src/vue/__tests__/queryClient.test.ts @@ -0,0 +1,550 @@ +import { ref } from "vue-demi"; +import { QueryClient as QueryClientOrigin } from "react-query/core"; + +import { QueryClient } from "../queryClient"; + +jest.mock("react-query/core"); + +const queryKeyRef = ["foo", ref("bar")]; +const queryKeyUnref = ["foo", "bar"]; + +const fn = () => {}; + +describe("QueryCache", () => { + // beforeAll(() => { + // jest.spyOn(QueryCacheOrigin.prototype, "find"); + // jest.spyOn(QueryCacheOrigin.prototype, "findAll"); + // }); + + beforeEach(() => { + jest.clearAllMocks(); + }); + + describe("isFetching", () => { + test("should properly unwrap 1 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.isFetching({ + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.isFetching).toBeCalledWith({ + queryKey: queryKeyUnref, + }); + }); + + test("should properly unwrap 2 parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.isFetching(queryKeyRef, { + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.isFetching).toBeCalledWith( + queryKeyUnref, + { + queryKey: queryKeyUnref, + } + ); + }); + }); + + describe("isMutating", () => { + test("should properly unwrap 1 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.isMutating({ + mutationKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.isMutating).toBeCalledWith({ + mutationKey: queryKeyUnref, + }); + }); + }); + + describe("getQueryData", () => { + test("should properly unwrap 2 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.getQueryData(queryKeyRef, { + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.getQueryData).toBeCalledWith( + queryKeyUnref, + { + queryKey: queryKeyUnref, + } + ); + }); + }); + + describe("getQueriesData", () => { + test("should properly unwrap queryKey param", async () => { + const queryClient = new QueryClient(); + + queryClient.getQueriesData(queryKeyRef); + + expect(QueryClientOrigin.prototype.getQueriesData).toBeCalledWith( + queryKeyUnref + ); + }); + + test("should properly unwrap filters param", async () => { + const queryClient = new QueryClient(); + + queryClient.getQueriesData({ queryKey: queryKeyRef }); + + expect(QueryClientOrigin.prototype.getQueriesData).toBeCalledWith({ + queryKey: queryKeyUnref, + }); + }); + }); + + describe("setQueryData", () => { + test("should properly unwrap 3 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.setQueryData(queryKeyRef, fn, { updatedAt: ref(3) }); + + expect(QueryClientOrigin.prototype.setQueryData).toBeCalledWith( + queryKeyUnref, + fn, + { updatedAt: 3 } + ); + }); + }); + + describe("setQueriesData", () => { + test("should properly unwrap params with queryKey", async () => { + const queryClient = new QueryClient(); + + queryClient.setQueriesData(queryKeyRef, fn, { updatedAt: ref(3) }); + + expect(QueryClientOrigin.prototype.setQueriesData).toBeCalledWith( + queryKeyUnref, + fn, + { updatedAt: 3 } + ); + }); + + test("should properly unwrap params with filters", async () => { + const queryClient = new QueryClient(); + + queryClient.setQueriesData({ queryKey: queryKeyRef }, fn, { + updatedAt: ref(3), + }); + + expect(QueryClientOrigin.prototype.setQueriesData).toBeCalledWith( + { queryKey: queryKeyUnref }, + fn, + { updatedAt: 3 } + ); + }); + }); + + describe("getQueryState", () => { + test("should properly unwrap 2 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.getQueryState(queryKeyRef, { queryKey: queryKeyRef }); + + expect(QueryClientOrigin.prototype.getQueryState).toBeCalledWith( + queryKeyUnref, + { queryKey: queryKeyUnref } + ); + }); + }); + + describe("removeQueries", () => { + test("should properly unwrap 1 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.removeQueries({ + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.removeQueries).toBeCalledWith({ + queryKey: queryKeyUnref, + }); + }); + + test("should properly unwrap 2 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.removeQueries(queryKeyRef, { + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.removeQueries).toBeCalledWith( + queryKeyUnref, + { + queryKey: queryKeyUnref, + } + ); + }); + }); + + describe("resetQueries", () => { + test("should properly unwrap 2 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.resetQueries( + { + queryKey: queryKeyRef, + }, + { cancelRefetch: ref(false) } + ); + + expect(QueryClientOrigin.prototype.resetQueries).toBeCalledWith( + { + queryKey: queryKeyUnref, + }, + { cancelRefetch: false } + ); + }); + + test("should properly unwrap 3 parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.resetQueries( + queryKeyRef, + { + queryKey: queryKeyRef, + }, + { cancelRefetch: ref(false) } + ); + + expect(QueryClientOrigin.prototype.resetQueries).toBeCalledWith( + queryKeyUnref, + { + queryKey: queryKeyUnref, + }, + { cancelRefetch: false } + ); + }); + }); + + describe("cancelQueries", () => { + test("should properly unwrap 2 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.cancelQueries( + { + queryKey: queryKeyRef, + }, + { revert: ref(false) } + ); + + expect(QueryClientOrigin.prototype.cancelQueries).toBeCalledWith( + { + queryKey: queryKeyUnref, + }, + { revert: false } + ); + }); + + test("should properly unwrap 3 parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.cancelQueries( + queryKeyRef, + { + queryKey: queryKeyRef, + }, + { revert: ref(false) } + ); + + expect(QueryClientOrigin.prototype.cancelQueries).toBeCalledWith( + queryKeyUnref, + { + queryKey: queryKeyUnref, + }, + { revert: false } + ); + }); + }); + + describe("invalidateQueries", () => { + test("should properly unwrap 2 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.invalidateQueries( + { + queryKey: queryKeyRef, + }, + { cancelRefetch: ref(false) } + ); + + expect(QueryClientOrigin.prototype.invalidateQueries).toBeCalledWith( + { + queryKey: queryKeyUnref, + }, + { cancelRefetch: false } + ); + }); + + test("should properly unwrap 3 parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.invalidateQueries( + queryKeyRef, + { + queryKey: queryKeyRef, + }, + { cancelRefetch: ref(false) } + ); + + expect(QueryClientOrigin.prototype.invalidateQueries).toBeCalledWith( + queryKeyUnref, + { + queryKey: queryKeyUnref, + }, + { cancelRefetch: false } + ); + }); + }); + + describe("refetchQueries", () => { + test("should properly unwrap 2 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.refetchQueries( + { + queryKey: queryKeyRef, + }, + { cancelRefetch: ref(false) } + ); + + expect(QueryClientOrigin.prototype.refetchQueries).toBeCalledWith( + { + queryKey: queryKeyUnref, + }, + { cancelRefetch: false } + ); + }); + + test("should properly unwrap 3 parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.refetchQueries( + queryKeyRef, + { + queryKey: queryKeyRef, + }, + { cancelRefetch: ref(false) } + ); + + expect(QueryClientOrigin.prototype.refetchQueries).toBeCalledWith( + queryKeyUnref, + { + queryKey: queryKeyUnref, + }, + { cancelRefetch: false } + ); + }); + }); + + describe("fetchQuery", () => { + test("should properly unwrap 1 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.fetchQuery({ + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.fetchQuery).toBeCalledWith({ + queryKey: queryKeyUnref, + }); + }); + + test("should properly unwrap 2 parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.fetchQuery(queryKeyRef, { + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.fetchQuery).toBeCalledWith( + queryKeyUnref, + { + queryKey: queryKeyUnref, + }, + undefined + ); + }); + + test("should properly unwrap 3 parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.fetchQuery(queryKeyRef, fn, { + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.fetchQuery).toBeCalledWith( + queryKeyUnref, + fn, + { + queryKey: queryKeyUnref, + } + ); + }); + }); + + describe("prefetchQuery", () => { + test("should properly unwrap parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.prefetchQuery(queryKeyRef, fn, { queryKey: queryKeyRef }); + + expect(QueryClientOrigin.prototype.prefetchQuery).toBeCalledWith( + queryKeyUnref, + fn, + { + queryKey: queryKeyUnref, + } + ); + }); + }); + + describe("fetchInfiniteQuery", () => { + test("should properly unwrap 1 parameter", async () => { + const queryClient = new QueryClient(); + + queryClient.fetchInfiniteQuery({ + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.fetchInfiniteQuery).toBeCalledWith({ + queryKey: queryKeyUnref, + }); + }); + + test("should properly unwrap 2 parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.fetchInfiniteQuery(queryKeyRef, { + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.fetchInfiniteQuery).toBeCalledWith( + queryKeyUnref, + { + queryKey: queryKeyUnref, + }, + undefined + ); + }); + + test("should properly unwrap 3 parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.fetchInfiniteQuery(queryKeyRef, fn, { + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.fetchInfiniteQuery).toBeCalledWith( + queryKeyUnref, + fn, + { + queryKey: queryKeyUnref, + } + ); + }); + }); + + describe("prefetchInfiniteQuery", () => { + test("should properly unwrap parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.prefetchInfiniteQuery(queryKeyRef, fn, { + queryKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.prefetchInfiniteQuery).toBeCalledWith( + queryKeyUnref, + fn, + { + queryKey: queryKeyUnref, + } + ); + }); + }); + + describe("setDefaultOptions", () => { + test("should properly unwrap parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.setDefaultOptions({ + queries: { + enabled: ref(false), + }, + }); + + expect(QueryClientOrigin.prototype.setDefaultOptions).toBeCalledWith({ + queries: { + enabled: false, + }, + }); + }); + }); + + describe("setQueryDefaults", () => { + test("should properly unwrap parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.setQueryDefaults(queryKeyRef, { + enabled: ref(false), + }); + + expect(QueryClientOrigin.prototype.setQueryDefaults).toBeCalledWith( + queryKeyUnref, + { + enabled: false, + } + ); + }); + }); + + describe("getQueryDefaults", () => { + test("should properly unwrap parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.getQueryDefaults(queryKeyRef); + + expect(QueryClientOrigin.prototype.getQueryDefaults).toBeCalledWith( + queryKeyUnref + ); + }); + }); + + describe("setMutationDefaults", () => { + test("should properly unwrap parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.setMutationDefaults(queryKeyRef, { + mutationKey: queryKeyRef, + }); + + expect(QueryClientOrigin.prototype.setMutationDefaults).toBeCalledWith( + queryKeyUnref, + { + mutationKey: queryKeyUnref, + } + ); + }); + }); + + describe("getMutationDefaults", () => { + test("should properly unwrap parameters", async () => { + const queryClient = new QueryClient(); + + queryClient.getMutationDefaults(queryKeyRef); + + expect(QueryClientOrigin.prototype.getMutationDefaults).toBeCalledWith( + queryKeyUnref + ); + }); + }); +}); diff --git a/src/vue/queryClient.ts b/src/vue/queryClient.ts index d02b4c6..dee2547 100644 --- a/src/vue/queryClient.ts +++ b/src/vue/queryClient.ts @@ -1,4 +1,3 @@ -import { isRef } from "vue-demi"; import { QueryClient as QC } from "react-query/core"; import type { QueryKey, @@ -26,14 +25,14 @@ import type { Updater, } from "react-query/types/core/utils"; import type { QueryState } from "react-query/types/core/query"; -import type { MaybeRef } from "./types"; +import type { MaybeRefDeep } from "./types"; import { cloneDeepUnref, isQueryKey } from "./utils"; import { QueryCache } from "./queryCache"; import { MutationCache } from "./mutationCache"; export class QueryClient extends QC { - constructor(config: MaybeRef = {}) { - const unreffedConfig = isRef(config) ? config.value : config; + constructor(config: MaybeRefDeep = {}) { + const unreffedConfig = cloneDeepUnref(config) as QueryClientConfig; const vueQueryConfig: QueryClientConfig = { defaultOptions: cloneDeepUnref(unreffedConfig.defaultOptions), queryCache: unreffedConfig.queryCache || new QueryCache(), @@ -42,129 +41,134 @@ export class QueryClient extends QC { super(vueQueryConfig); } - isFetching(filters?: MaybeRef): number; + isFetching(filters?: MaybeRefDeep): number; isFetching( - queryKey?: MaybeRef, - filters?: MaybeRef + queryKey?: MaybeRefDeep, + filters?: MaybeRefDeep ): number; isFetching( - arg1?: MaybeRef, - arg2?: MaybeRef + arg1?: MaybeRefDeep, + arg2?: MaybeRefDeep ): number { const arg1Unreffed = cloneDeepUnref(arg1); + const arg2Unreffed = cloneDeepUnref(arg2) as QueryFilters; if (isQueryKey(arg1Unreffed)) { - return super.isFetching(arg1Unreffed, cloneDeepUnref(arg2)); + return super.isFetching(arg1Unreffed, arg2Unreffed); } - return super.isFetching(arg1Unreffed); + return super.isFetching(arg1Unreffed as QueryFilters); } - isMutating(filters?: MaybeRef): number { - return super.isMutating(cloneDeepUnref(filters)); + isMutating(filters?: MaybeRefDeep): number { + return super.isMutating(cloneDeepUnref(filters) as MutationFilters); } getQueryData( - queryKey: MaybeRef, - filters?: MaybeRef + queryKey: MaybeRefDeep, + filters?: MaybeRefDeep ): TData | undefined { return super.getQueryData( cloneDeepUnref(queryKey), - cloneDeepUnref(filters) + cloneDeepUnref(filters) as QueryFilters ); } getQueriesData( - queryKey: MaybeRef + queryKey: MaybeRefDeep ): [QueryKey, TData][]; getQueriesData( - filters: MaybeRef + filters: MaybeRefDeep ): [QueryKey, TData][]; getQueriesData( - queryKeyOrFilters: MaybeRef | MaybeRef + queryKeyOrFilters: MaybeRefDeep | MaybeRefDeep ): [QueryKey, TData][] { const unreffed = cloneDeepUnref(queryKeyOrFilters); if (isQueryKey(unreffed)) { return super.getQueriesData(unreffed); } - return super.getQueriesData(unreffed); + return super.getQueriesData(unreffed as QueryFilters); } setQueryData( - queryKey: MaybeRef, + queryKey: MaybeRefDeep, updater: Updater, - options?: MaybeRef + options?: MaybeRefDeep ): TData { return super.setQueryData( cloneDeepUnref(queryKey), updater, - cloneDeepUnref(options) + cloneDeepUnref(options) as SetDataOptions ); } setQueriesData( - queryKey: MaybeRef, + queryKey: MaybeRefDeep, updater: Updater, - options?: MaybeRef + options?: MaybeRefDeep ): [QueryKey, TData][]; setQueriesData( - filters: MaybeRef, + filters: MaybeRefDeep, updater: Updater, - options?: MaybeRef + options?: MaybeRefDeep ): [QueryKey, TData][]; setQueriesData( - queryKeyOrFilters: MaybeRef, + queryKeyOrFilters: MaybeRefDeep, updater: Updater, - options?: MaybeRef + options?: MaybeRefDeep ): [QueryKey, TData][] { const arg1Unreffed = cloneDeepUnref(queryKeyOrFilters); + const arg3Unreffed = cloneDeepUnref(options) as SetDataOptions; if (isQueryKey(arg1Unreffed)) { - return super.setQueriesData( - arg1Unreffed, - updater, - cloneDeepUnref(options) - ); + return super.setQueriesData(arg1Unreffed, updater, arg3Unreffed); } - return super.setQueriesData(arg1Unreffed, updater, cloneDeepUnref(options)); + return super.setQueriesData( + arg1Unreffed as QueryFilters, + updater, + arg3Unreffed + ); } getQueryState( - queryKey: MaybeRef, - filters?: MaybeRef + queryKey: MaybeRefDeep, + filters?: MaybeRefDeep ): QueryState | undefined { return super.getQueryState( cloneDeepUnref(queryKey), - cloneDeepUnref(filters) + cloneDeepUnref(filters) as QueryFilters ); } - removeQueries(filters?: MaybeRef): void; + removeQueries(filters?: MaybeRefDeep): void; removeQueries( - queryKey?: MaybeRef, - filters?: MaybeRef + queryKey?: MaybeRefDeep, + filters?: MaybeRefDeep ): void; removeQueries( - arg1?: MaybeRef, - arg2?: MaybeRef + arg1?: MaybeRefDeep, + arg2?: MaybeRefDeep ): void { const arg1Unreffed = cloneDeepUnref(arg1); if (isQueryKey(arg1Unreffed)) { - return super.removeQueries(arg1Unreffed, cloneDeepUnref(arg2)); + return super.removeQueries( + arg1Unreffed, + cloneDeepUnref(arg2) as QueryFilters + ); } - return super.removeQueries(arg1Unreffed); + return super.removeQueries(arg1Unreffed as QueryFilters); } resetQueries( - filters?: MaybeRef>, - options?: MaybeRef + filters?: MaybeRefDeep>, + options?: MaybeRefDeep ): Promise; resetQueries( - queryKey?: MaybeRef, - filters?: MaybeRef>, - options?: MaybeRef + queryKey?: MaybeRefDeep, + filters?: MaybeRefDeep>, + options?: MaybeRefDeep ): Promise; resetQueries( - arg1?: MaybeRef>, - arg2?: MaybeRef | ResetOptions>, - arg3?: MaybeRef + arg1?: MaybeRefDeep>, + arg2?: MaybeRefDeep | ResetOptions>, + arg3?: MaybeRefDeep ): Promise { const arg1Unreffed = cloneDeepUnref(arg1); const arg2Unreffed = cloneDeepUnref(arg2); @@ -172,25 +176,28 @@ export class QueryClient extends QC { return super.resetQueries( arg1Unreffed, arg2Unreffed as ResetQueryFilters | undefined, - cloneDeepUnref(arg3) + cloneDeepUnref(arg3) as ResetOptions ); } - return super.resetQueries(arg1Unreffed, arg2Unreffed as ResetOptions); + return super.resetQueries( + arg1Unreffed as ResetQueryFilters, + arg2Unreffed as ResetOptions + ); } cancelQueries( - filters?: MaybeRef, - options?: MaybeRef + filters?: MaybeRefDeep, + options?: MaybeRefDeep ): Promise; cancelQueries( - queryKey?: MaybeRef, - filters?: MaybeRef, - options?: MaybeRef + queryKey?: MaybeRefDeep, + filters?: MaybeRefDeep, + options?: MaybeRefDeep ): Promise; cancelQueries( - arg1?: MaybeRef, - arg2?: MaybeRef, - arg3?: MaybeRef + arg1?: MaybeRefDeep, + arg2?: MaybeRefDeep, + arg3?: MaybeRefDeep ): Promise { const arg1Unreffed = cloneDeepUnref(arg1); const arg2Unreffed = cloneDeepUnref(arg2); @@ -198,25 +205,28 @@ export class QueryClient extends QC { return super.cancelQueries( arg1Unreffed, arg2Unreffed as QueryFilters | undefined, - cloneDeepUnref(arg3) + cloneDeepUnref(arg3) as CancelOptions ); } - return super.cancelQueries(arg1Unreffed, arg2Unreffed as CancelOptions); + return super.cancelQueries( + arg1Unreffed as QueryFilters, + arg2Unreffed as CancelOptions + ); } invalidateQueries( - filters?: MaybeRef>, - options?: MaybeRef + filters?: MaybeRefDeep>, + options?: MaybeRefDeep ): Promise; invalidateQueries( - queryKey?: MaybeRef, - filters?: MaybeRef>, - options?: MaybeRef + queryKey?: MaybeRefDeep, + filters?: MaybeRefDeep>, + options?: MaybeRefDeep ): Promise; invalidateQueries( - arg1?: MaybeRef>, - arg2?: MaybeRef | InvalidateOptions>, - arg3?: MaybeRef + arg1?: MaybeRefDeep>, + arg2?: MaybeRefDeep | InvalidateOptions>, + arg3?: MaybeRefDeep ): Promise { const arg1Unreffed = cloneDeepUnref(arg1); const arg2Unreffed = cloneDeepUnref(arg2); @@ -224,28 +234,28 @@ export class QueryClient extends QC { return super.invalidateQueries( arg1Unreffed, arg2Unreffed as InvalidateQueryFilters | undefined, - cloneDeepUnref(arg3) + cloneDeepUnref(arg3) as InvalidateOptions ); } return super.invalidateQueries( - arg1Unreffed, + arg1Unreffed as InvalidateQueryFilters, arg2Unreffed as InvalidateOptions ); } refetchQueries( - filters?: MaybeRef>, - options?: MaybeRef + filters?: MaybeRefDeep>, + options?: MaybeRefDeep ): Promise; refetchQueries( - queryKey?: MaybeRef, - filters?: MaybeRef>, - options?: MaybeRef + queryKey?: MaybeRefDeep, + filters?: MaybeRefDeep>, + options?: MaybeRefDeep ): Promise; refetchQueries( - arg1?: MaybeRef>, - arg2?: MaybeRef | RefetchOptions>, - arg3?: MaybeRef + arg1?: MaybeRefDeep>, + arg2?: MaybeRefDeep | RefetchOptions>, + arg3?: MaybeRefDeep ): Promise { const arg1Unreffed = cloneDeepUnref(arg1); const arg2Unreffed = cloneDeepUnref(arg2); @@ -253,10 +263,13 @@ export class QueryClient extends QC { return super.refetchQueries( arg1Unreffed, arg2Unreffed as RefetchQueryFilters | undefined, - cloneDeepUnref(arg3) + cloneDeepUnref(arg3) as RefetchOptions ); } - return super.refetchQueries(arg1Unreffed, arg2Unreffed as RefetchOptions); + return super.refetchQueries( + arg1Unreffed as RefetchQueryFilters, + arg2Unreffed as RefetchOptions + ); } fetchQuery< @@ -265,7 +278,9 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - options: MaybeRef> + options: MaybeRefDeep< + FetchQueryOptions + > ): Promise; fetchQuery< TQueryFnData = unknown, @@ -273,8 +288,8 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - queryKey: MaybeRef, - options?: MaybeRef< + queryKey: MaybeRefDeep, + options?: MaybeRefDeep< FetchQueryOptions > ): Promise; @@ -284,9 +299,9 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - queryKey: MaybeRef, + queryKey: MaybeRefDeep, queryFn: QueryFunction, - options?: MaybeRef< + options?: MaybeRefDeep< FetchQueryOptions > ): Promise; @@ -297,12 +312,14 @@ export class QueryClient extends QC { TQueryKey extends QueryKey = QueryKey >( arg1: - | MaybeRef - | MaybeRef>, + | MaybeRefDeep + | MaybeRefDeep>, arg2?: | QueryFunction - | MaybeRef>, - arg3?: MaybeRef> + | MaybeRefDeep>, + arg3?: MaybeRefDeep< + FetchQueryOptions + > ): Promise { const arg1Unreffed = cloneDeepUnref(arg1); const arg2Unreffed = cloneDeepUnref(arg2); @@ -329,7 +346,9 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - options: MaybeRef> + options: MaybeRefDeep< + FetchQueryOptions + > ): Promise; prefetchQuery< TQueryFnData = unknown, @@ -337,8 +356,8 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - queryKey: MaybeRef, - options?: MaybeRef< + queryKey: MaybeRefDeep, + options?: MaybeRefDeep< FetchQueryOptions > ): Promise; @@ -348,9 +367,9 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - queryKey: MaybeRef, + queryKey: MaybeRefDeep, queryFn: QueryFunction, - options?: MaybeRef< + options?: MaybeRefDeep< FetchQueryOptions > ): Promise; @@ -360,13 +379,15 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - arg1: MaybeRef< + arg1: MaybeRefDeep< TQueryKey | FetchQueryOptions >, arg2?: | QueryFunction - | MaybeRef>, - arg3?: MaybeRef> + | MaybeRefDeep>, + arg3?: MaybeRefDeep< + FetchQueryOptions + > ): Promise { return super.prefetchQuery( cloneDeepUnref(arg1) as any, @@ -381,7 +402,7 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - options: MaybeRef< + options: MaybeRefDeep< FetchInfiniteQueryOptions > ): Promise>; @@ -391,8 +412,8 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - queryKey: MaybeRef, - options?: MaybeRef< + queryKey: MaybeRefDeep, + options?: MaybeRefDeep< FetchInfiniteQueryOptions > ): Promise>; @@ -402,9 +423,9 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - queryKey: MaybeRef, + queryKey: MaybeRefDeep, queryFn: QueryFunction, - options?: MaybeRef< + options?: MaybeRefDeep< FetchInfiniteQueryOptions > ): Promise>; @@ -414,16 +435,16 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - arg1: MaybeRef< + arg1: MaybeRefDeep< | TQueryKey | FetchInfiniteQueryOptions >, arg2?: | QueryFunction - | MaybeRef< + | MaybeRefDeep< FetchInfiniteQueryOptions >, - arg3?: MaybeRef< + arg3?: MaybeRefDeep< FetchInfiniteQueryOptions > ): Promise> { @@ -457,7 +478,7 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - options: MaybeRef< + options: MaybeRefDeep< FetchInfiniteQueryOptions > ): Promise; @@ -467,8 +488,8 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - queryKey: MaybeRef, - options?: MaybeRef< + queryKey: MaybeRefDeep, + options?: MaybeRefDeep< FetchInfiniteQueryOptions > ): Promise; @@ -478,9 +499,9 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - queryKey: MaybeRef, + queryKey: MaybeRefDeep, queryFn: QueryFunction, - options?: MaybeRef< + options?: MaybeRefDeep< FetchInfiniteQueryOptions > ): Promise; @@ -490,16 +511,16 @@ export class QueryClient extends QC { TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey >( - arg1: MaybeRef< + arg1: MaybeRefDeep< | TQueryKey | FetchInfiniteQueryOptions >, arg2?: | QueryFunction - | MaybeRef< + | MaybeRefDeep< FetchInfiniteQueryOptions >, - arg3?: MaybeRef< + arg3?: MaybeRefDeep< FetchInfiniteQueryOptions > ): Promise { @@ -510,35 +531,38 @@ export class QueryClient extends QC { ); } - setDefaultOptions(options: MaybeRef): void { - super.setDefaultOptions(cloneDeepUnref(options)); + setDefaultOptions(options: MaybeRefDeep): void { + super.setDefaultOptions(cloneDeepUnref(options) as DefaultOptions); } setQueryDefaults( - queryKey: MaybeRef, - options: MaybeRef> + queryKey: MaybeRefDeep, + options: MaybeRefDeep> ): void { - super.setQueryDefaults(cloneDeepUnref(queryKey), cloneDeepUnref(options)); + super.setQueryDefaults( + cloneDeepUnref(queryKey), + cloneDeepUnref(options) as any + ); } getQueryDefaults( - queryKey?: MaybeRef + queryKey?: MaybeRefDeep ): QueryObserverOptions | undefined { return super.getQueryDefaults(cloneDeepUnref(queryKey)); } setMutationDefaults( - mutationKey: MaybeRef, - options: MaybeRef> + mutationKey: MaybeRefDeep, + options: MaybeRefDeep> ): void { super.setMutationDefaults( cloneDeepUnref(mutationKey), - cloneDeepUnref(options) + cloneDeepUnref(options) as any ); } getMutationDefaults( - mutationKey?: MaybeRef + mutationKey?: MaybeRefDeep ): MutationObserverOptions | undefined { return super.getMutationDefaults(cloneDeepUnref(mutationKey)); } diff --git a/src/vue/types.ts b/src/vue/types.ts index 196a95d..56cec7a 100644 --- a/src/vue/types.ts +++ b/src/vue/types.ts @@ -9,7 +9,7 @@ export type MaybeRef = Ref | T; export type MaybeRefDeep = MaybeRef< T extends object ? { - [Property in keyof T]: MaybeRef; + [Property in keyof T]: MaybeRefDeep; } : T >;