@wisemen/vue-core-api-utils 1.0.0-beta.2 → 1.0.1

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { err, ok } from "neverthrow";
-import { useInfiniteQuery, useMutation as useMutation$1, useQuery as useQuery$1, useQueryClient } from "@tanstack/vue-query";
-import { computed, unref } from "vue";
+import { QueryClient as QueryClient$1, VueQueryPlugin, useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/vue-query";
+import { computed } from "vue";
 
 //#region src/async-result/asyncResult.ts
 /**
@@ -135,72 +135,8 @@ const AsyncResult = {
 		return AsyncResultOk._create(value);
 	}
 };
-
-//#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 && mutation.error.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
-	};
+function isAsyncResult(value) {
+	return value instanceof AsyncResultErr || value instanceof AsyncResultLoading || value instanceof AsyncResultOk;
 }
 
 //#endregion
@@ -211,6 +147,34 @@ const QUERY_CONFIG = {
 	prefetchStaleTime: DEFAULT_PREFETCH_STALE_TIME,
 	limit: DEFAULT_LIMIT$3
 };
+let globalQueryClient = null;
+/**
+* Initialize the API utilities with a QueryClient.
+* Call this once during app setup (e.g. in a plugin or main.ts).
+*
+* After calling this, `createApiUtils()` can be called without options.
+*
+* @example
+* ```typescript
+* import { initializeApiUtils } from '@wisemen/vue-core-api-utils'
+*
+* const queryClient = new QueryClient()
+* initializeApiUtils(queryClient)
+*
+* // Then in your api lib:
+* export const { useQuery, useMutation, ... } = createApiUtils<MyQueryKeys>()
+* ```
+*/
+function initializeApiUtils(queryClient) {
+	globalQueryClient = queryClient;
+}
+/**
+* @internal
+*/
+function getQueryClient() {
+	if (globalQueryClient == null) throw new Error("[api-utils] QueryClient not available. Call initializeApiUtils(queryClient) before using createApiUtils().");
+	return globalQueryClient;
+}
 function setQueryConfig(config) {
 	if (config.limit != null && config.limit > 0) QUERY_CONFIG.limit = config.limit;
 	if (config.prefetchStaleTime != null && config.prefetchStaleTime > 0) QUERY_CONFIG.prefetchStaleTime = config.prefetchStaleTime;
@@ -228,15 +192,17 @@ function useKeysetInfiniteQuery(options) {
 		staleTime: options.staleTime,
 		enabled: options.isEnabled,
 		getNextPageParam: (lastPage) => {
-			if (lastPage.isErr()) return null;
-			return lastPage.value.meta.next ?? null;
+			if (lastPage.isErr() || lastPage.isLoading()) return null;
+			return lastPage.getValue().meta.next ?? null;
 		},
 		initialPageParam: void 0,
 		placeholderData: (data) => data,
-		queryFn: ({ pageParam }) => options.queryFn({
-			key: pageParam,
-			limit: options.limit ?? DEFAULT_LIMIT$2
-		}),
+		queryFn: async ({ pageParam }) => {
+			return AsyncResult.fromResult(await options.queryFn({
+				key: pageParam,
+				limit: options.limit ?? DEFAULT_LIMIT$2
+			}));
+		},
 		queryKey: getQueryKey()
 	});
 	const hasError = computed(() => {
@@ -245,10 +211,10 @@ function useKeysetInfiniteQuery(options) {
 	const result = computed(() => {
 		if (infiniteQuery.isLoading.value) return AsyncResult.loading();
 		const firstError = infiniteQuery.data.value?.pages.find((page) => page.isErr());
-		if (firstError) return AsyncResult.err(firstError.error);
-		const data = infiniteQuery.data.value?.pages.filter((page) => page.isOk()).flatMap((page) => page.value.data) ?? [];
+		if (firstError) return AsyncResult.err(firstError.getError());
+		const data = infiniteQuery.data.value?.pages.filter((page) => page.isOk()).flatMap((page) => page.getValue().data) ?? [];
 		const firstPage = infiniteQuery.data.value?.pages[0];
-		const meta = firstPage?.isOk() ? firstPage.value.meta : { next: null };
+		const meta = firstPage?.isOk() ? firstPage.getValue().meta : { next: null };
 		const response = {
 			data,
 			meta: { next: infiniteQuery.hasNextPage.value ? meta.next : null }
@@ -290,17 +256,17 @@ function useOffsetInfiniteQuery(options) {
 		staleTime: options.staleTime,
 		enabled: options.isEnabled,
 		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;
+			if (lastPage.isErr() || lastPage.isLoading()) return null;
+			const total = lastPage.getValue().meta.offset + lastPage.getValue().meta.limit;
+			if (total >= lastPage.getValue().meta.total) return null;
 			return total;
 		},
 		initialPageParam: 0,
 		placeholderData: (data) => data,
-		queryFn: ({ pageParam }) => options.queryFn({
+		queryFn: async ({ pageParam }) => AsyncResult.fromResult(await options.queryFn({
 			limit: options.limit ?? DEFAULT_LIMIT$1,
 			offset: pageParam ?? 0
-		}),
+		})),
 		queryKey: getQueryKey()
 	});
 	const hasError = computed(() => {
@@ -309,10 +275,10 @@ function useOffsetInfiniteQuery(options) {
 	const result = computed(() => {
 		if (infiniteQuery.isLoading.value) return AsyncResult.loading();
 		const firstError = infiniteQuery.data.value?.pages.find((page) => page.isErr());
-		if (firstError) return AsyncResult.err(firstError.error);
-		const data = infiniteQuery.data.value?.pages.filter((page) => page.isOk()).flatMap((page) => page.value.data) ?? [];
+		if (firstError) return AsyncResult.err(firstError.getError());
+		const data = infiniteQuery.data.value?.pages.filter((page) => page.isOk()).flatMap((page) => page.getValue().data) ?? [];
 		const firstPage = infiniteQuery.data.value?.pages[0];
-		const meta = firstPage?.isOk() ? firstPage.value.meta : null;
+		const meta = firstPage?.isOk() ? firstPage.getValue().meta : null;
 		const response = {
 			data,
 			meta: {
@@ -344,62 +310,6 @@ function useOffsetInfiniteQuery(options) {
 	};
 }
 
-//#endregion
-//#region src/composables/query/prefetchQuery.composable.ts
-function usePrefetchQuery(query) {
-	const queryClient = useQueryClient();
-	function getQueryKey() {
-		const [first] = Object.entries(query.queryKey);
-		if (!first) return [];
-		const [queryKey, params] = first;
-		return [queryKey, params];
-	}
-	async function execute() {
-		await queryClient.prefetchQuery({
-			staleTime: query.staleTime ?? QUERY_CONFIG.prefetchStaleTime,
-			queryFn: query.queryFn,
-			queryKey: getQueryKey()
-		});
-	}
-	return { execute };
-}
-
-//#endregion
-//#region src/composables/query/query.composable.ts
-function useQuery(options) {
-	const isDebug = options.isDebug ?? false;
-	const query = useQuery$1({
-		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/createApiInfiniteQueryUtils.ts
 function createApiInfiniteQueryUtils() {
@@ -431,11 +341,78 @@ function createApiInfiniteQueryUtils() {
 	};
 }
 
+//#endregion
+//#region src/composables/mutation/mutation.composable.ts
+function useMutation$1(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({
+		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/factory/createApiMutationUtils.ts
 function createApiMutationUtils() {
 	function useMutation$2(options) {
-		return useMutation({
+		return useMutation$1({
 			isDebug: options.isDebug,
 			queryFn: options.queryFn,
 			queryKeysToInvalidate: options.queryKeysToInvalidate ?? {}
@@ -445,11 +422,84 @@ function createApiMutationUtils() {
 }
 
 //#endregion
-//#region src/utils/optimisticUpdates.ts
+//#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 };
+	}
+	return {
+		usePrefetchKeysetInfiniteQuery,
+		usePrefetchOffsetInfiniteQuery
+	};
+}
+
+//#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
+			});
+		}
+		return { execute };
+	}
+	return { usePrefetchQuery };
+}
+
+//#endregion
+//#region src/utils/query-client/queryClient.ts
 /**
-* OptimisticUpdates utility class for type-safe optimistic updates
+* QueryClient utility class for type-safe query operations
 */
-var OptimisticUpdates = class {
+var QueryClient = class {
 	constructor(queryClient) {
 		this.queryClient = queryClient;
 	}
@@ -457,13 +507,11 @@ var OptimisticUpdates = class {
 	* Extract the raw entity from AsyncResult data
 	*/
 	extractEntityFromAsyncResult(data) {
-		if (data === void 0 || data === null) return null;
-		if (typeof data === "object" && "isOk" in data) {
-			const asyncResult = data;
-			if (asyncResult.isOk()) return asyncResult.getValue();
-			return null;
-		}
-		return data;
+		if (data.isOk()) return data.getValue();
+		return null;
+	}
+	hasDataArray(value) {
+		return Boolean(value && typeof value === "object" && Array.isArray(value.data));
 	}
 	isInfiniteDataLike(data) {
 		return Boolean(data && typeof data === "object" && "pages" in data && Array.isArray(data.pages));
@@ -471,33 +519,26 @@ var OptimisticUpdates = class {
 	/**
 	* Determine if an item should be updated
 	*/
-	shouldUpdateItem(by, item, value) {
-		if (typeof by === "function") return by(item);
-		if (by && typeof by === "object") return Object.entries(by).every(([key, matchValue]) => {
-			const itemValue = item[key];
-			return unref(itemValue) === unref(matchValue);
-		});
-		const idFromValue = value.id;
-		const itemId = item["id"];
-		if (idFromValue !== void 0 && itemId !== void 0) return unref(itemId) === unref(idFromValue);
-		return false;
+	shouldUpdateItem(by, item) {
+		return by(item);
 	}
 	/**
 	* Internal method to update entity based on the "by" option
 	*/
 	updateEntity(by, currentData, value) {
 		if (Array.isArray(currentData)) return currentData.map((item) => {
-			return this.shouldUpdateItem(by, item, value) ? {
-				...item,
-				...value
-			} : item;
+			return this.shouldUpdateItem(by, item) ? value(item) : item;
 		});
-		if (this.shouldUpdateItem(by, currentData, value)) return {
-			...currentData,
-			...value
-		};
+		if (this.shouldUpdateItem(by, currentData)) return value(currentData);
 		return currentData;
 	}
+	updateInfinitePageValue(by, value, pageValue) {
+		if (!this.hasDataArray(pageValue)) return pageValue;
+		return {
+			...pageValue,
+			data: this.updateEntity(by, pageValue.data, value)
+		};
+	}
 	/**
 	* Wrap a raw entity in an AsyncResult (preserving ok state)
 	*/
@@ -507,11 +548,13 @@ var OptimisticUpdates = class {
 	get(queryKey, options) {
 		if (Array.isArray(queryKey)) {
 			const data = this.queryClient.getQueryData(queryKey);
+			if (data == null) return null;
 			return this.extractEntityFromAsyncResult(data);
 		}
 		if (options?.isExact ?? false) {
 			const normalizedKey = [queryKey];
 			const data = this.queryClient.getQueryData(normalizedKey);
+			if (data == null) return null;
 			return this.extractEntityFromAsyncResult(data);
 		}
 		const allQueries = this.queryClient.getQueryCache().findAll({ predicate: (query) => {
@@ -544,7 +587,7 @@ var OptimisticUpdates = class {
 		this.queryClient.setQueryData(normalizedKey, wrappedData);
 	}
 	update(keyOrTuple, options) {
-		const by = options.by ?? void 0;
+		const by = options.by;
 		const value = options.value;
 		const isSpecific = Array.isArray(keyOrTuple);
 		const key = isSpecific ? keyOrTuple[0] : keyOrTuple;
@@ -563,19 +606,14 @@ var OptimisticUpdates = class {
 				const updatedInfiniteData = {
 					...currentData,
 					pages: currentData.pages.map((page) => {
-						if (page && typeof page === "object" && "map" in page && typeof page.map === "function") return page.map((pageValue) => {
-							if (pageValue && typeof pageValue === "object" && Array.isArray(pageValue.data)) return {
-								...pageValue,
-								data: this.updateEntity(by, pageValue.data, value)
-							};
-							return pageValue;
-						});
-						return page;
+						if (!isAsyncResult(page)) return page;
+						return page.map((pageValue) => this.updateInfinitePageValue(by, value, pageValue));
 					})
 				};
 				this.queryClient.setQueryData(query.queryKey, updatedInfiniteData);
 				continue;
 			}
+			if (!isAsyncResult(currentData)) continue;
 			const rawEntity = this.extractEntityFromAsyncResult(currentData);
 			if (rawEntity === null) continue;
 			const updatedEntity = this.updateEntity(by, rawEntity, value);
@@ -584,100 +622,59 @@ var OptimisticUpdates = class {
 		}
 	}
 };
-/**
-* Create an OptimisticUpdates instance
-*/
-function createOptimisticUpdates(queryClient) {
-	return new OptimisticUpdates(queryClient);
-}
 
 //#endregion
-//#region src/factory/createApiOptimisticUpdatesUtils.ts
-function createApiOptimisticUpdatesUtils(options) {
-	function useOptimisticUpdates() {
-		return new OptimisticUpdates(options.queryClient);
+//#region src/factory/createApiQueryClientUtils.ts
+function createApiQueryClientUtils() {
+	function useQueryClient$1() {
+		return new QueryClient(getQueryClient());
 	}
-	return { useOptimisticUpdates };
+	return { useQueryClient: useQueryClient$1 };
 }
 
 //#endregion
-//#region src/factory/createApiPrefetchInfiniteQueryUtils.ts
-const DEFAULT_LIMIT = QUERY_CONFIG.limit;
-function createApiPrefetchInfiniteQueryUtils(options) {
-	function usePrefetchOffsetInfiniteQuery(key, queryOptions) {
-		const queryKey = [key, queryOptions.params ?? {}];
-		async function execute() {
-			await options.queryClient.prefetchInfiniteQuery({
-				staleTime: queryOptions.staleTime,
-				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 };
+//#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];
 	}
-	function usePrefetchKeysetInfiniteQuery(key, queryOptions) {
-		const queryKey = [key, queryOptions.params ?? {}];
-		async function execute() {
-			await options.queryClient.prefetchInfiniteQuery({
-				staleTime: queryOptions.staleTime,
-				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 };
+	async function refetch() {
+		await query.refetch();
 	}
 	return {
-		usePrefetchKeysetInfiniteQuery,
-		usePrefetchOffsetInfiniteQuery
+		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/createApiPrefetchQueryUtils.ts
-function createApiPrefetchQueryUtils(options) {
-	function usePrefetchQuery$1(key, queryOptions) {
-		const queryKey = [key, queryOptions.params ?? {}];
-		async function execute() {
-			await options.queryClient.prefetchQuery({
-				staleTime: queryOptions.staleTime ?? QUERY_CONFIG.prefetchStaleTime,
-				queryFn: async () => {
-					return AsyncResult.fromResult(await queryOptions.queryFn());
-				},
-				queryKey
-			});
-		}
-		return { execute };
-	}
-	return { usePrefetchQuery: usePrefetchQuery$1 };
-}
-
 //#endregion
 //#region src/factory/createApiQueryUtils.ts
 function createApiQueryUtils() {
 	function useQuery$2(key, queryOptions) {
 		const params = queryOptions.params ?? {};
 		const queryKey = { [key]: params };
-		return useQuery({
+		return useQuery$1({
 			staleTime: queryOptions.staleTime,
 			isDebug: queryOptions.isDebug,
 			isEnabled: queryOptions.isEnabled,
@@ -692,18 +689,76 @@ function createApiQueryUtils() {
 //#region src/factory/createApiUtils.ts
 /**
 * Factory that creates typed composables based on a user-provided query-keys config.
-* This is an alternative to module augmentation of `QueryKeys`.
+*
+* 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(options) {
+function createApiUtils() {
 	return {
 		...createApiQueryUtils(),
-		...createApiPrefetchQueryUtils(options),
-		...createApiPrefetchInfiniteQueryUtils(options),
+		...createApiPrefetchQueryUtils(),
+		...createApiPrefetchInfiniteQueryUtils(),
 		...createApiInfiniteQueryUtils(),
 		...createApiMutationUtils(),
-		...createApiOptimisticUpdatesUtils(options)
+		...createApiQueryClientUtils()
 	};
 }
 
 //#endregion
-export { AsyncResult, AsyncResultErr, AsyncResultLoading, AsyncResultOk, OptimisticUpdates, createApiInfiniteQueryUtils, createApiMutationUtils, createApiOptimisticUpdatesUtils, createApiPrefetchInfiniteQueryUtils, createApiPrefetchQueryUtils, createApiQueryUtils, createApiUtils, createOptimisticUpdates, setQueryConfig, useKeysetInfiniteQuery, useMutation, useOffsetInfiniteQuery, usePrefetchQuery, useQuery };
+//#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 {
+	static toDto(sort, sortKeyMap) {
+		return sort.filter((s) => s.direction !== null).map((s) => ({
+			key: sortKeyMap[s.key],
+			order: s.direction === SortDirection.ASC ? SortDirection.ASC : SortDirection.DESC
+		}));
+	}
+};
+
+//#endregion
+export { ApiError, ApiErrorObject, ApiExpectedError, ApiKnownErrorObject, ApiResult, ApiUnexpectedError, ApiUnknownErrorObject, AsyncApiResult, AsyncResult, AsyncResultErr, AsyncResultLoading, AsyncResultOk, KeysetPagination, KeysetPaginationParams, KeysetPaginationResponse, KeysetPaginationResult, OffsetPagination, OffsetPaginationParams, OffsetPaginationResponse, OffsetPaginationResult, PaginatedDataDto, QueryClient, QueryClientUpdateOptions, Sort, SortDirection, SortUtil, apiUtilsPlugin, createApiInfiniteQueryUtils, createApiMutationUtils, createApiPrefetchInfiniteQueryUtils, createApiPrefetchQueryUtils, createApiQueryClientUtils, createApiQueryUtils, createApiUtils, getQueryClient as getTanstackQueryClient, initializeApiUtils, setQueryConfig };