@wisemen/vue-core-api-utils 1.2.0 → 2.0.1

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { err, ok } from "neverthrow";
-import { QueryClient as QueryClient$1, VueQueryPlugin, useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/vue-query";
+import { ResultAsync, err, ok } from "neverthrow";
+import { QueryClient as QueryClient$1, VueQueryPlugin, useInfiniteQuery, useMutation as useMutation$1, useQuery as useQuery$1, useQueryClient } from "@tanstack/vue-query";
 import { computed } from "vue";
+import z from "zod";
 
 //#region src/async-result/asyncResult.ts
 /**
@@ -139,13 +140,80 @@ function isAsyncResult(value) {
 	return value instanceof AsyncResultErr || value instanceof AsyncResultLoading || value instanceof AsyncResultOk;
 }
 
+//#endregion
+//#region src/composables/mutation/mutation.composable.ts
+function useMutation(options) {
+	const isDebug = options.isDebug ?? false;
+	const queryClient = useQueryClient();
+	async function onSuccess(responseData, params) {
+		if (!options.queryKeysToInvalidate) return;
+		await Promise.all(Object.entries(options.queryKeysToInvalidate).map(async ([queryKey, queryKeyParams]) => {
+			if (!queryKeyParams) {
+				if (isDebug) console.log(`[MUTATION] Invalidating ${queryKey}`);
+				await queryClient.invalidateQueries({ queryKey: [queryKey] });
+				return;
+			}
+			const qkp = queryKeyParams;
+			const paramEntries = Object.entries(qkp);
+			if (paramEntries.length === 0) {
+				if (isDebug) console.log(`[MUTATION] Invalidating ${queryKey}`);
+				await queryClient.invalidateQueries({ queryKey: [queryKey] });
+				return;
+			}
+			const paramsWithValues = paramEntries.reduce((acc, [key, value]) => {
+				acc[key] = value(params, responseData);
+				return acc;
+			}, {});
+			if (isDebug) console.log(`[MUTATION] Invalidating ${queryKey}`, paramsWithValues);
+			await queryClient.invalidateQueries({
+				exact: false,
+				queryKey: [queryKey, paramsWithValues]
+			});
+		}));
+	}
+	const mutation = useMutation$1({
+		mutationFn: options.queryFn,
+		onSuccess: async (result$1, variables) => {
+			if (!result$1.isOk()) return;
+			const data = result$1.value;
+			if (variables !== void 0 && "params" in variables) {
+				await onSuccess(data, variables.params);
+				return;
+			}
+			await onSuccess(data, {});
+		}
+	});
+	async function execute(data) {
+		return await mutation.mutateAsync(data);
+	}
+	const result = computed(() => {
+		if (mutation.isPending.value) return AsyncResult.loading();
+		if (mutation.isError.value) return AsyncResult.err(mutation.error.value);
+		if (mutation.isSuccess.value && mutation.data.value !== void 0) {
+			const apiResult = mutation.data.value;
+			if (apiResult.isOk()) return AsyncResult.ok(apiResult.value);
+			if (apiResult.isErr()) return AsyncResult.err(apiResult.error);
+		}
+		return AsyncResult.loading();
+	});
+	return {
+		isLoading: computed(() => mutation.isPending.value),
+		data: computed(() => {
+			if (mutation.data.value?.isOk()) return mutation.data.value.value;
+			return null;
+		}),
+		execute,
+		result
+	};
+}
+
 //#endregion
 //#region src/config/config.ts
-const DEFAULT_LIMIT$3 = 20;
+const DEFAULT_LIMIT$2 = 20;
 const DEFAULT_PREFETCH_STALE_TIME = 60;
 const QUERY_CONFIG = {
 	prefetchStaleTime: DEFAULT_PREFETCH_STALE_TIME,
-	limit: DEFAULT_LIMIT$3
+	limit: DEFAULT_LIMIT$2
 };
 let globalQueryClient = null;
 /**
@@ -182,12 +250,9 @@ function setQueryConfig(config) {
 
 //#endregion
 //#region src/composables/query/keysetInfiniteQuery.composable.ts
-const DEFAULT_LIMIT$2 = QUERY_CONFIG.limit;
-function useKeysetInfiniteQuery(options) {
-	function getQueryKey() {
-		const [queryKey, params] = Object.entries(options.queryKey)[0];
-		return [queryKey, params];
-	}
+const DEFAULT_LIMIT$1 = QUERY_CONFIG.limit;
+function useKeysetInfiniteQuery(key, options) {
+	const queryKey = [key, options.params];
 	const infiniteQuery = useInfiniteQuery({
 		staleTime: options.staleTime,
 		enabled: options.isEnabled,
@@ -200,10 +265,10 @@ function useKeysetInfiniteQuery(options) {
 		queryFn: async ({ pageParam }) => {
 			return AsyncResult.fromResult(await options.queryFn({
 				key: pageParam,
-				limit: options.limit ?? DEFAULT_LIMIT$2
+				limit: options.limit ?? DEFAULT_LIMIT$1
 			}));
 		},
-		queryKey: getQueryKey()
+		queryKey
 	});
 	const hasError = computed(() => {
 		return Boolean(infiniteQuery.data.value?.pages.find((page) => page.isErr()));
@@ -244,14 +309,9 @@ function useKeysetInfiniteQuery(options) {
 
 //#endregion
 //#region src/composables/query/offsetInfiniteQuery.composable.ts
-const DEFAULT_LIMIT$1 = QUERY_CONFIG.limit;
-function useOffsetInfiniteQuery(options) {
-	function getQueryKey() {
-		const [first] = Object.entries(options.queryKey);
-		if (!first) return [];
-		const [queryKey, params] = first;
-		return [queryKey, params];
-	}
+const DEFAULT_LIMIT = QUERY_CONFIG.limit;
+function useOffsetInfiniteQuery(key, options) {
+	const queryKey = [key, options.params];
 	const infiniteQuery = useInfiniteQuery({
 		staleTime: options.staleTime,
 		enabled: options.isEnabled,
@@ -264,10 +324,10 @@ function useOffsetInfiniteQuery(options) {
 		initialPageParam: 0,
 		placeholderData: (data) => data,
 		queryFn: async ({ pageParam }) => AsyncResult.fromResult(await options.queryFn({
-			limit: options.limit ?? DEFAULT_LIMIT$1,
+			limit: options.limit ?? DEFAULT_LIMIT,
 			offset: pageParam ?? 0
 		})),
-		queryKey: getQueryKey()
+		queryKey
 	});
 	const hasError = computed(() => {
 		return Boolean(infiniteQuery.data.value?.pages.find((page) => page.isErr()));
@@ -311,188 +371,193 @@ function useOffsetInfiniteQuery(options) {
 }
 
 //#endregion
-//#region src/factory/createApiInfiniteQueryUtils.ts
-function createApiInfiniteQueryUtils() {
-	function useOffsetInfiniteQuery$1(key, queryOptions) {
-		const params = queryOptions.params ?? {};
-		const queryKey = { [key]: params };
-		return useOffsetInfiniteQuery({
-			staleTime: queryOptions.staleTime,
-			isEnabled: queryOptions.isEnabled,
-			limit: queryOptions.limit,
-			queryFn: queryOptions.queryFn,
-			queryKey
+//#region src/composables/query/prefetchKeysetInfiniteQuery.composable.ts
+function usePrefetchKeysetInfiniteQuery(key, options) {
+	const queryClient = useQueryClient();
+	const params = options.params;
+	async function execute() {
+		await queryClient.prefetchInfiniteQuery({
+			staleTime: options.staleTime ?? QUERY_CONFIG.prefetchStaleTime,
+			getNextPageParam: (lastPage) => {
+				if (!lastPage.isOk()) return null;
+				const next = lastPage.getValue().meta.next;
+				return next === null || next === void 0 ? null : next;
+			},
+			initialPageParam: void 0,
+			queryFn: async ({ pageParam }) => AsyncResult.fromResult(await options.queryFn({
+				key: pageParam,
+				limit: options.limit ?? QUERY_CONFIG.limit
+			})),
+			queryKey: [key, params]
 		});
 	}
-	function useKeysetInfiniteQuery$1(key, queryOptions) {
-		const params = queryOptions.params ?? {};
-		const queryKey = { [key]: params };
-		return useKeysetInfiniteQuery({
-			staleTime: queryOptions.staleTime,
-			isEnabled: queryOptions.isEnabled,
-			limit: queryOptions.limit,
-			queryFn: queryOptions.queryFn,
-			queryKey
+	return { execute };
+}
+
+//#endregion
+//#region src/composables/query/prefetchOffsetInfiniteQuery.composable.ts
+function usePrefetchOffsetInfiniteQuery(key, options) {
+	const queryClient = useQueryClient();
+	const params = options.params;
+	async function execute() {
+		await queryClient.prefetchInfiniteQuery({
+			staleTime: options.staleTime ?? QUERY_CONFIG.prefetchStaleTime,
+			getNextPageParam: (lastPage) => {
+				if (!lastPage.isOk()) return null;
+				const total = lastPage.getValue().meta.offset + lastPage.getValue().meta.limit;
+				if (total >= lastPage.getValue().meta.total) return null;
+				return total;
+			},
+			initialPageParam: 0,
+			queryFn: async ({ pageParam }) => AsyncResult.fromResult(await options.queryFn({
+				limit: options.limit ?? QUERY_CONFIG.limit,
+				offset: pageParam ?? 0
+			})),
+			queryKey: [key, params]
 		});
 	}
-	return {
-		useKeysetInfiniteQuery: useKeysetInfiniteQuery$1,
-		useOffsetInfiniteQuery: useOffsetInfiniteQuery$1
-	};
+	return { execute };
 }
 
 //#endregion
-//#region src/composables/mutation/mutation.composable.ts
-function useMutation$1(options) {
-	const isDebug = options.isDebug ?? false;
+//#region src/composables/query/prefetchQuery.composable.ts
+function usePrefetchQuery(key, options) {
 	const queryClient = useQueryClient();
-	async function onSuccess(responseData, params) {
-		if (!options.queryKeysToInvalidate) return;
-		await Promise.all(Object.entries(options.queryKeysToInvalidate).map(async ([queryKey, queryKeyParams]) => {
-			if (!queryKeyParams) {
-				if (isDebug) console.log(`[MUTATION] Invalidating ${queryKey}`);
-				await queryClient.invalidateQueries({ queryKey: [queryKey] });
-				return;
-			}
-			const qkp = queryKeyParams;
-			const paramEntries = Object.entries(qkp);
-			if (paramEntries.length === 0) {
-				if (isDebug) console.log(`[MUTATION] Invalidating ${queryKey}`);
-				await queryClient.invalidateQueries({ queryKey: [queryKey] });
-				return;
-			}
-			const paramsWithValues = paramEntries.reduce((acc, [key, value]) => {
-				acc[key] = value(params, responseData);
-				return acc;
-			}, {});
-			if (isDebug) console.log(`[MUTATION] Invalidating ${queryKey}`, paramsWithValues);
-			await queryClient.invalidateQueries({
-				exact: false,
-				queryKey: [queryKey, paramsWithValues]
-			});
-		}));
+	const params = options.params;
+	async function execute() {
+		await queryClient.prefetchQuery({
+			staleTime: options.staleTime ?? QUERY_CONFIG.prefetchStaleTime,
+			queryFn: async () => AsyncResult.fromResult(await options.queryFn()),
+			queryKey: [key, params]
+		});
 	}
-	const mutation = useMutation({
-		mutationFn: options.queryFn,
-		onSuccess: async (result$1, variables) => {
-			if (!result$1.isOk()) return;
-			const data = result$1.value;
-			if (variables !== void 0 && "params" in variables) {
-				await onSuccess(data, variables.params);
-				return;
-			}
-			await onSuccess(data, {});
-		}
+	return { execute };
+}
+
+//#endregion
+//#region src/composables/query/query.composable.ts
+function useQuery(key, options) {
+	const isDebug = options.isDebug ?? false;
+	const params = options.params;
+	const query = useQuery$1({
+		staleTime: options.staleTime,
+		enabled: options.isEnabled,
+		placeholderData: (data) => data,
+		queryFn: async () => {
+			return AsyncResult.fromResult(await options.queryFn());
+		},
+		queryKey: [key, params]
 	});
-	async function execute(data) {
-		return await mutation.mutateAsync(data);
+	if (isDebug) console.debug(`Create query with key ${String(key)}`, params);
+	async function refetch() {
+		await query.refetch();
 	}
-	const result = computed(() => {
-		if (mutation.isPending.value) return AsyncResult.loading();
-		if (mutation.isError.value) return AsyncResult.err(mutation.error.value);
-		if (mutation.isSuccess.value && mutation.data.value !== void 0) {
-			const apiResult = mutation.data.value;
-			if (apiResult.isOk()) return AsyncResult.ok(apiResult.value);
-			if (apiResult.isErr()) return AsyncResult.err(apiResult.error);
-		}
-		return AsyncResult.loading();
-	});
 	return {
-		isLoading: computed(() => mutation.isPending.value),
-		data: computed(() => {
-			if (mutation.data.value?.isOk()) return mutation.data.value.value;
-			return null;
-		}),
-		execute,
-		result
+		isError: computed(() => query.data.value?.isErr() ?? false),
+		isFetching: computed(() => query.isFetching.value),
+		isLoading: computed(() => query.isLoading.value),
+		isSuccess: computed(() => query.data.value?.isOk() ?? false),
+		refetch,
+		result: computed(() => {
+			if (query.isLoading.value) return AsyncResult.loading();
+			if (query.data.value?.isOk()) return AsyncResult.ok(query.data.value.getValue());
+			if (query.data.value?.isErr()) return AsyncResult.err(query.data.value.getError());
+			return AsyncResult.loading();
+		})
 	};
 }
 
 //#endregion
-//#region src/factory/createApiMutationUtils.ts
-function createApiMutationUtils() {
-	function useMutation$2(options) {
-		return useMutation$1({
-			isDebug: options.isDebug,
-			queryFn: options.queryFn,
-			queryKeysToInvalidate: options.queryKeysToInvalidate ?? {}
-		});
-	}
-	return { useMutation: useMutation$2 };
+//#region src/plugin/apiUtilsPlugin.ts
+/**
+* Create a Vue plugin that sets up TanStack Query and initializes API utilities.
+*
+* This plugin handles:
+* - Creating a QueryClient with the provided config
+* - Installing VueQueryPlugin on the app
+* - Initializing the global QueryClient for api-utils
+*
+* @example
+* ```typescript
+* import { apiUtilsPlugin } from '@wisemen/vue-core-api-utils'
+* import { vueQueryClientConfig } from '@wisemen/vue-core-configs'
+*
+* app.use(apiUtilsPlugin(vueQueryClientConfig()))
+* ```
+*
+* @param config - QueryClient configuration
+* @returns A Vue plugin that can be used with app.use()
+*/
+function apiUtilsPlugin(config) {
+	const queryClient = new QueryClient$1(config);
+	return { install: (app) => {
+		app.use(VueQueryPlugin, { queryClient });
+		initializeApiUtils(queryClient);
+	} };
 }
 
 //#endregion
-//#region src/factory/createApiPrefetchInfiniteQueryUtils.ts
-const DEFAULT_LIMIT = QUERY_CONFIG.limit;
-function createApiPrefetchInfiniteQueryUtils() {
-	function usePrefetchOffsetInfiniteQuery(key, queryOptions) {
-		const queryKey = [key, queryOptions.params ?? {}];
-		const queryClient = getQueryClient();
-		async function execute() {
-			await queryClient.prefetchInfiniteQuery({
-				staleTime: queryOptions.staleTime ?? QUERY_CONFIG.prefetchStaleTime,
-				getNextPageParam: (lastPage) => {
-					if (lastPage.isErr()) return null;
-					const total = lastPage.value.meta.offset + lastPage.value.meta.limit;
-					if (total >= lastPage.value.meta.total) return null;
-					return total;
-				},
-				initialPageParam: 0,
-				queryFn: ({ pageParam }) => queryOptions.queryFn({
-					limit: queryOptions.limit ?? DEFAULT_LIMIT,
-					offset: pageParam ?? 0
-				}),
-				queryKey
-			});
-		}
-		return { execute };
-	}
-	function usePrefetchKeysetInfiniteQuery(key, queryOptions) {
-		const queryKey = [key, queryOptions.params ?? {}];
-		async function execute() {
-			await getQueryClient().prefetchInfiniteQuery({
-				staleTime: queryOptions.staleTime ?? QUERY_CONFIG.prefetchStaleTime,
-				getNextPageParam: (lastPage) => {
-					if (lastPage.isErr()) return null;
-					const next = lastPage.value.meta.next;
-					if (next === null || next === void 0) return null;
-					return next;
-				},
-				initialPageParam: void 0,
-				queryFn: ({ pageParam }) => queryOptions.queryFn({
-					key: pageParam,
-					limit: queryOptions.limit ?? DEFAULT_LIMIT
-				}),
-				queryKey
-			});
-		}
-		return { execute };
+//#region src/types/sort.type.ts
+let SortDirection = /* @__PURE__ */ function(SortDirection$1) {
+	SortDirection$1["ASC"] = "asc";
+	SortDirection$1["DESC"] = "desc";
+	return SortDirection$1;
+}({});
+
+//#endregion
+//#region src/utils/api-error/apiError.util.ts
+var ApiErrorUtil = class ApiErrorUtil {
+	static getApiErrorCode(error) {
+		return error.errors?.[0]?.code ?? null;
 	}
-	return {
-		usePrefetchKeysetInfiniteQuery,
-		usePrefetchOffsetInfiniteQuery
-	};
-}
+	static getApiErrorMessage(error) {
+		return error.errors?.[0]?.detail ?? null;
+	}
+	static getMessage(error) {
+		return error.errors?.[0]?.detail ?? null;
+	}
+	static handleApiError({ error, message }) {
+		if (ApiErrorUtil.isExpectedApiError(error)) return error;
+		console.error(`Unexpected API error: ${error}`);
+		if (error instanceof Error) return error;
+		return new Error(message ?? "An unknown error occurred");
+	}
+	static isExpectedApiError(error) {
+		return error?.errors !== void 0;
+	}
+	static isZodError(error) {
+		return error instanceof z.ZodError;
+	}
+};
 
 //#endregion
-//#region src/factory/createApiPrefetchQueryUtils.ts
-function createApiPrefetchQueryUtils() {
-	function usePrefetchQuery(key, queryOptions) {
-		const queryClient = getQueryClient();
-		const queryKey = [key, queryOptions.params ?? {}];
-		async function execute() {
-			await queryClient.prefetchQuery({
-				staleTime: queryOptions.staleTime ?? QUERY_CONFIG.prefetchStaleTime,
-				queryFn: async () => {
-					return AsyncResult.fromResult(await queryOptions.queryFn());
-				},
-				queryKey
+//#region src/utils/api/api.util.ts
+var ApiUtil = class ApiUtil {
+	static async fromPromise(promise, message) {
+		return await ResultAsync.fromPromise(promise, (error) => {
+			return ApiErrorUtil.handleApiError({
+				error,
+				message
 			});
-		}
-		return { execute };
+		});
 	}
-	return { usePrefetchQuery };
-}
+	static getKeysetPaginationNextOffset(keysetPaginationMeta) {
+		return keysetPaginationMeta.next?.offset ?? null;
+	}
+	static getResultError(result) {
+		if (result === null) return null;
+		if (!result.isErr()) return null;
+		if (ApiUtil.isAsyncResult(result)) return result.getError();
+		return result.error;
+	}
+	static isAsyncResult(value) {
+		return value.getResult !== void 0;
+	}
+	static void(result) {
+		if (result.isErr()) return err(result.error);
+		return ok();
+	}
+};
 
 //#endregion
 //#region src/utils/query-client/queryClient.ts
@@ -632,132 +697,6 @@ var QueryClient = class {
 	}
 };
 
-//#endregion
-//#region src/factory/createApiQueryClientUtils.ts
-function createApiQueryClientUtils() {
-	function useQueryClient$1() {
-		return new QueryClient(getQueryClient());
-	}
-	return { useQueryClient: useQueryClient$1 };
-}
-
-//#endregion
-//#region src/composables/query/query.composable.ts
-function useQuery$1(options) {
-	const isDebug = options.isDebug ?? false;
-	const query = useQuery({
-		staleTime: options.staleTime,
-		enabled: options.isEnabled,
-		placeholderData: (data) => data,
-		queryFn: async () => {
-			return AsyncResult.fromResult(await options.queryFn());
-		},
-		queryKey: getQueryKey()
-	});
-	function getQueryKey() {
-		const [queryKey, params] = Object.entries(options.queryKey)[0];
-		if (isDebug) console.debug(`Create query with key ${queryKey}`, params);
-		return [queryKey, params];
-	}
-	async function refetch() {
-		await query.refetch();
-	}
-	return {
-		isError: computed(() => query.data.value?.isErr() ?? false),
-		isFetching: computed(() => query.isFetching.value),
-		isLoading: computed(() => query.isLoading.value),
-		isSuccess: computed(() => query.data.value?.isOk() ?? false),
-		refetch,
-		result: computed(() => {
-			if (query.isLoading.value) return AsyncResult.loading();
-			if (query.data.value?.isOk()) return AsyncResult.ok(query.data.value.getValue());
-			if (query.data.value?.isErr()) return AsyncResult.err(query.data.value.getError());
-			return AsyncResult.loading();
-		})
-	};
-}
-
-//#endregion
-//#region src/factory/createApiQueryUtils.ts
-function createApiQueryUtils() {
-	function useQuery$2(key, queryOptions) {
-		const params = queryOptions.params ?? {};
-		const queryKey = { [key]: params };
-		return useQuery$1({
-			staleTime: queryOptions.staleTime,
-			isDebug: queryOptions.isDebug,
-			isEnabled: queryOptions.isEnabled,
-			queryFn: queryOptions.queryFn,
-			queryKey
-		});
-	}
-	return { useQuery: useQuery$2 };
-}
-
-//#endregion
-//#region src/factory/createApiUtils.ts
-/**
-* Factory that creates typed composables based on a user-provided query-keys config.
-*
-* Requires `initializeApiUtils(queryClient)` to be called first.
-*
-* @example
-* ```typescript
-* // In app setup (plugin or main.ts):
-* initializeApiUtils(queryClient)
-*
-* // In your api lib:
-* export const { useQuery, useMutation, useQueryClient } = createApiUtils<MyQueryKeys>()
-* ```
-*/
-function createApiUtils() {
-	return {
-		...createApiQueryUtils(),
-		...createApiPrefetchQueryUtils(),
-		...createApiPrefetchInfiniteQueryUtils(),
-		...createApiInfiniteQueryUtils(),
-		...createApiMutationUtils(),
-		...createApiQueryClientUtils()
-	};
-}
-
-//#endregion
-//#region src/plugin/apiUtilsPlugin.ts
-/**
-* Create a Vue plugin that sets up TanStack Query and initializes API utilities.
-*
-* This plugin handles:
-* - Creating a QueryClient with the provided config
-* - Installing VueQueryPlugin on the app
-* - Initializing the global QueryClient for api-utils
-*
-* @example
-* ```typescript
-* import { apiUtilsPlugin } from '@wisemen/vue-core-api-utils'
-* import { vueQueryClientConfig } from '@wisemen/vue-core-configs'
-*
-* app.use(apiUtilsPlugin(vueQueryClientConfig()))
-* ```
-*
-* @param config - QueryClient configuration
-* @returns A Vue plugin that can be used with app.use()
-*/
-function apiUtilsPlugin(config) {
-	const queryClient = new QueryClient$1(config);
-	return { install: (app) => {
-		app.use(VueQueryPlugin, { queryClient });
-		initializeApiUtils(queryClient);
-	} };
-}
-
-//#endregion
-//#region src/types/sort.type.ts
-let SortDirection = /* @__PURE__ */ function(SortDirection$1) {
-	SortDirection$1["ASC"] = "asc";
-	SortDirection$1["DESC"] = "desc";
-	return SortDirection$1;
-}({});
-
 //#endregion
 //#region src/utils/sort/sort.utils.ts
 var SortUtil = class {
@@ -770,4 +709,4 @@ var SortUtil = class {
 };
 
 //#endregion
-export { AsyncResult, AsyncResultErr, AsyncResultLoading, AsyncResultOk, QueryClient, SortDirection, SortUtil, apiUtilsPlugin, createApiUtils, getQueryClient as getTanstackQueryClient, initializeApiUtils, setQueryConfig };
+export { ApiErrorUtil, ApiUtil, AsyncResult, AsyncResultErr, AsyncResultLoading, AsyncResultOk, QueryClient, SortDirection, SortUtil, apiUtilsPlugin, getQueryClient as getTanstackQueryClient, initializeApiUtils, setQueryConfig, useKeysetInfiniteQuery, useMutation, useOffsetInfiniteQuery, usePrefetchKeysetInfiniteQuery, usePrefetchOffsetInfiniteQuery, usePrefetchQuery, useQuery };

package/package.json

@@ -4,7 +4,7 @@
     "access": "public"
   },
   "type": "module",
-  "version": "1.2.0",
+  "version": "2.0.1",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {
     "type": "git",
@@ -35,6 +35,7 @@
   "peerDependencies": {
     "@tanstack/vue-query": ">=5.90.5",
     "neverthrow": ">=8.2.0",
+    "zod": ">=4.3.5",
     "vue": ">=3.5.22"
   },
   "devDependencies": {
@@ -45,7 +46,7 @@
     "typescript": "5.9.3",
     "vue": "3.5.27",
     "vitest": "4.1.0",
-    "@wisemen/eslint-config-vue": "2.1.2"
+    "@wisemen/eslint-config-vue": "2.1.3"
   },
   "scripts": {
     "build": "tsdown",