@classytic/arc-next 0.3.1 → 0.4.0

package/dist/hooks.js

@@ -4,8 +4,8 @@ import { getAuthContext, getAuthMode } from "./client.js";
 import { isKeysetPagination, isOffsetPagination } from "./api.js";
 import { DEFAULT_QUERY_CONFIG, createCacheUtils, createQueryKeys, extractItem, getItemId, updateListCache, useDetailQuery, useInfiniteListQuery, useListQuery } from "./query.js";
 import { useMutationWithTransition, useOptimisticMutation } from "./mutation.js";
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { useCallback, useMemo, useRef } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useRef } from "react";
 
 //#region src/hooks.ts
 let useRouterHook = null;
@@ -25,7 +25,18 @@ function createEnabledRule(token, options, authMode = getAuthMode()) {
 	if (authMode === "cookie" || options.public) return options.enabled ?? true;
 	return options.enabled !== void 0 ? options.enabled && !!token : !!token;
 }
-function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks = {}, client }) {
+function createCrudHooks({ api, entityKey, singular, plural, idField, defaults = {}, callbacks = {}, client }) {
+	const pluralName = plural ?? `${singular}s`;
+	/** Extract ID from an item using configured idField, falling back to _id → id */
+	function resolveItemId(item) {
+		if (!item || typeof item !== "object") return null;
+		const obj = item;
+		if (idField) {
+			const val = obj[idField];
+			if (val != null) return String(val);
+		}
+		return getItemId(item);
+	}
 	const KEYS = createQueryKeys(entityKey);
 	const cache = createCacheUtils(KEYS);
 	const instanceToast = client?.toast;
@@ -91,6 +102,7 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 			},
 			prefillDetailCache: queryOpts.prefillDetailCache ?? true,
 			detailKeyBuilder: (id) => KEYS.detail(id),
+			itemIdResolver: resolveItemId,
 			select: queryOpts.select
 		});
 	}
@@ -151,7 +163,7 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 				const optimisticItem = {
 					...data,
 					_optimistic: true,
-					[getItemId(data) ? "id" : "_id"]: getItemId(data) ?? `temp-${Date.now()}`
+					[idField ?? (resolveItemId(data) ? "id" : "_id")]: resolveItemId(data) ?? `temp-${Date.now()}`
 				};
 				return updateListCache(oldData, (arr) => [optimisticItem, ...arr || []]);
 			},
@@ -181,7 +193,7 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 			queryKeys: [KEYS.lists(), KEYS.details()],
 			shouldToast,
 			optimisticUpdate: (oldData, { id, data }) => {
-				const updated = updateListCache(oldData, (arr) => (arr || []).map((item) => getItemId(item) === id ? {
+				const updated = updateListCache(oldData, (arr) => (arr || []).map((item) => resolveItemId(item) === id ? {
 					...item,
 					...data
 				} : item));
@@ -229,7 +241,7 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 			queryKeys: [KEYS.lists()],
 			shouldToast,
 			optimisticUpdate: (oldData, { id }) => {
-				return updateListCache(oldData, (arr) => (arr || []).filter((item) => getItemId(item) !== id));
+				return updateListCache(oldData, (arr) => (arr || []).filter((item) => resolveItemId(item) !== id));
 			},
 			onSuccess: (data, { id }) => {
 				queryClient.removeQueries({ queryKey: KEYS.detail(id) });
@@ -247,6 +259,23 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 			},
 			toastHandler: instanceToast
 		});
+		const restoreMutation = useMutationWithTransition({
+			mutationFn: ({ token, organizationId, id }) => {
+				if (!api.restore) return Promise.reject(/* @__PURE__ */ new Error(`[arc-next] "${entityKey}" api does not define a restore method`));
+				return api.restore({
+					token,
+					organizationId,
+					id
+				});
+			},
+			invalidateQueries: [KEYS.lists(), KEYS.custom("deleted")],
+			shouldToast,
+			messages: {
+				success: `${singular} restored successfully`,
+				error: `Failed to restore ${singular.toLowerCase()}`
+			},
+			toastHandler: instanceToast
+		});
 		const resolveAuth = useCallback((params) => {
 			const auth = getAuthContext();
 			return {
@@ -301,10 +330,26 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 					silentRef.current = false;
 				}
 			}, [deleteMutation, resolveAuth]),
+			restore: useCallback(async (params, options) => {
+				silentRef.current = options?.silent ?? false;
+				try {
+					const entity = extractItem(await restoreMutation.mutateAsync(resolveAuth(params)));
+					options?.onSuccess?.(entity);
+					options?.onSettled?.(entity, null);
+					return entity;
+				} catch (error) {
+					options?.onError?.(error);
+					options?.onSettled?.(void 0, error);
+					throw error;
+				} finally {
+					silentRef.current = false;
+				}
+			}, [restoreMutation, resolveAuth]),
 			isCreating: createMutation.isPending,
 			isUpdating: updateMutation.isPending,
 			isDeleting: deleteMutation.isPending,
-			isMutating: createMutation.isPending || updateMutation.isPending || deleteMutation.isPending
+			isRestoring: restoreMutation.isPending,
+			isMutating: createMutation.isPending || updateMutation.isPending || deleteMutation.isPending || restoreMutation.isPending
 		};
 	}
 	function useInfiniteList(tokenOrParams, paramsOrOptions, maybeOptions) {
@@ -357,6 +402,13 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 				const p = page;
 				if (typeof p.hasNext === "boolean" && typeof p.page === "number") return p.hasNext ? p.page + 1 : void 0;
 			},
+			getPreviousPageParam: queryOpts.maxPages != null ? (firstPage) => {
+				const page = firstPage;
+				if (isOffsetPagination(page)) return page.hasPrev ? page.page - 1 : void 0;
+				const p = page;
+				if (typeof p.hasPrev === "boolean" && typeof p.page === "number") return p.hasPrev ? p.page - 1 : void 0;
+			} : void 0,
+			maxPages: queryOpts.maxPages,
 			options: {
 				staleTime: queryOpts.staleTime ?? config.staleTime,
 				gcTime: queryOpts.gcTime ?? config.gcTime,
@@ -392,8 +444,6 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 		});
 	}
 	function useSearch(query, params, options) {
-		if (!api.search) throw new Error(`[arc-next] "${entityKey}" api does not define a search method`);
-		const searchApi = api.search;
 		const auth = getAuthContext();
 		const token = params?.token ?? auth.token;
 		const organizationId = params?.organizationId ?? auth.organizationId;
@@ -413,16 +463,19 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 				"search",
 				searchKeyParams
 			],
-			queryFn: ({ signal }) => searchApi({
-				token,
-				organizationId,
-				params: searchParams,
-				options: {
-					signal,
-					...requestOpts
-				}
-			}),
-			enabled: query.length > 0 && createEnabledRule(token, queryOpts, resolveAuthMode()),
+			queryFn: ({ signal }) => {
+				if (!api.search) return Promise.reject(/* @__PURE__ */ new Error(`[arc-next] "${entityKey}" api does not define a search method`));
+				return api.search({
+					token,
+					organizationId,
+					params: searchParams,
+					options: {
+						signal,
+						...requestOpts
+					}
+				});
+			},
+			enabled: !!api.search && query.length > 0 && createEnabledRule(token, queryOpts, resolveAuthMode()),
 			options: {
 				staleTime: queryOpts.staleTime ?? config.staleTime,
 				gcTime: queryOpts.gcTime ?? config.gcTime
@@ -441,6 +494,243 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 			toastHandler: instanceToast
 		});
 	}
+	function useDeleted(params, options) {
+		const auth = getAuthContext();
+		const token = auth.token;
+		const mergedParams = params ?? {};
+		const organizationId = mergedParams.organizationId ?? auth.organizationId;
+		const { organizationId: _, ...restParams } = mergedParams;
+		const { request: requestOpts, ...queryOpts } = options ?? {};
+		return useListQuery({
+			queryKey: KEYS.custom("deleted", {
+				organizationId,
+				...restParams
+			}),
+			queryFn: ({ signal }) => {
+				if (!api.getDeleted) return Promise.reject(/* @__PURE__ */ new Error(`[arc-next] "${entityKey}" api does not define a getDeleted method`));
+				return api.getDeleted({
+					token,
+					organizationId,
+					params: restParams,
+					options: {
+						signal,
+						...requestOpts
+					}
+				});
+			},
+			enabled: !!api.getDeleted && createEnabledRule(token, queryOpts, resolveAuthMode()),
+			options: {
+				staleTime: queryOpts.staleTime ?? config.staleTime,
+				gcTime: queryOpts.gcTime ?? config.gcTime
+			},
+			select: queryOpts.select
+		});
+	}
+	function useDetailBySlug(slug, options) {
+		const auth = getAuthContext();
+		const token = auth.token;
+		const resolvedOptions = options ?? {};
+		const organizationId = resolvedOptions.organizationId ?? auth.organizationId;
+		const { params: queryParams, request: requestOpts, ...restOptions } = resolvedOptions;
+		return useDetailQuery({
+			queryKey: queryParams ? KEYS.custom("slug", slug, queryParams) : KEYS.custom("slug", slug),
+			queryFn: ({ signal }) => {
+				if (!api.getBySlug) return Promise.reject(/* @__PURE__ */ new Error(`[arc-next] "${entityKey}" api does not define a getBySlug method`));
+				return api.getBySlug({
+					slug,
+					token,
+					organizationId,
+					params: queryParams,
+					options: {
+						signal,
+						...requestOpts
+					}
+				});
+			},
+			enabled: !!api.getBySlug && !!slug && createEnabledRule(token, restOptions, resolveAuthMode()),
+			options: {
+				staleTime: restOptions.staleTime ?? config.staleTime,
+				gcTime: restOptions.gcTime ?? config.gcTime,
+				refetchOnWindowFocus: restOptions.refetchOnWindowFocus ?? config.refetchOnWindowFocus,
+				structuralSharing: restOptions.structuralSharing ?? config.structuralSharing
+			},
+			select: restOptions.select
+		});
+	}
+	function useTree(params, options) {
+		const auth = getAuthContext();
+		const token = auth.token;
+		const mergedParams = params ?? {};
+		const organizationId = mergedParams.organizationId ?? auth.organizationId;
+		const { organizationId: _, ...restParams } = mergedParams;
+		const { request: requestOpts, ...queryOpts } = options ?? {};
+		return useListQuery({
+			queryKey: KEYS.custom("tree", {
+				organizationId,
+				...restParams
+			}),
+			queryFn: ({ signal }) => {
+				if (!api.getTree) return Promise.reject(/* @__PURE__ */ new Error(`[arc-next] "${entityKey}" api does not define a getTree method`));
+				return api.getTree({
+					token,
+					organizationId,
+					params: restParams,
+					options: {
+						signal,
+						...requestOpts
+					}
+				});
+			},
+			enabled: !!api.getTree && createEnabledRule(token, queryOpts, resolveAuthMode()),
+			options: {
+				staleTime: queryOpts.staleTime ?? config.staleTime,
+				gcTime: queryOpts.gcTime ?? config.gcTime
+			},
+			select: queryOpts.select
+		});
+	}
+	function useChildren(parentId, params, options) {
+		const auth = getAuthContext();
+		const token = auth.token;
+		const mergedParams = params ?? {};
+		const organizationId = mergedParams.organizationId ?? auth.organizationId;
+		const { organizationId: _, ...restParams } = mergedParams;
+		const { request: requestOpts, ...queryOpts } = options ?? {};
+		return useListQuery({
+			queryKey: KEYS.custom("children", parentId, {
+				organizationId,
+				...restParams
+			}),
+			queryFn: ({ signal }) => {
+				if (!api.getChildren) return Promise.reject(/* @__PURE__ */ new Error(`[arc-next] "${entityKey}" api does not define a getChildren method`));
+				return api.getChildren({
+					token,
+					organizationId,
+					parentId,
+					params: restParams,
+					options: {
+						signal,
+						...requestOpts
+					}
+				});
+			},
+			enabled: !!api.getChildren && !!parentId && createEnabledRule(token, queryOpts, resolveAuthMode()),
+			options: {
+				staleTime: queryOpts.staleTime ?? config.staleTime,
+				gcTime: queryOpts.gcTime ?? config.gcTime
+			},
+			prefillDetailCache: queryOpts.prefillDetailCache ?? true,
+			detailKeyBuilder: (id) => KEYS.detail(id),
+			itemIdResolver: resolveItemId,
+			select: queryOpts.select
+		});
+	}
+	function useFindBy(field, value, options) {
+		const auth = getAuthContext();
+		const token = auth.token;
+		const organizationId = auth.organizationId;
+		const { operator, request: requestOpts, ...queryOpts } = options ?? {};
+		return useListQuery({
+			queryKey: KEYS.custom("findBy", field, value, operator),
+			queryFn: ({ signal }) => {
+				if (!api.findBy) return Promise.reject(/* @__PURE__ */ new Error(`[arc-next] "${entityKey}" api does not define a findBy method`));
+				return api.findBy({
+					token,
+					organizationId,
+					field,
+					value,
+					operator,
+					options: {
+						signal,
+						...requestOpts
+					}
+				});
+			},
+			enabled: !!api.findBy && value !== void 0 && value !== null && createEnabledRule(token, queryOpts, resolveAuthMode()),
+			options: {
+				staleTime: queryOpts.staleTime ?? config.staleTime,
+				gcTime: queryOpts.gcTime ?? config.gcTime
+			},
+			prefillDetailCache: queryOpts.prefillDetailCache ?? true,
+			detailKeyBuilder: (id) => KEYS.detail(id),
+			itemIdResolver: resolveItemId,
+			select: queryOpts.select
+		});
+	}
+	function useBulkActions() {
+		const bulkCreateMutation = useMutationWithTransition({
+			mutationFn: (vars) => {
+				if (!api.bulkCreate) return Promise.reject(/* @__PURE__ */ new Error(`[arc-next] "${entityKey}" api does not define a bulkCreate method`));
+				const auth = getAuthContext();
+				return api.bulkCreate({
+					token: vars.token ?? auth.token,
+					organizationId: vars.organizationId ?? auth.organizationId,
+					data: vars.data
+				});
+			},
+			invalidateQueries: [KEYS.lists()],
+			messages: {
+				success: `${pluralName} created successfully`,
+				error: `Failed to create ${pluralName.toLowerCase()}`
+			},
+			toastHandler: instanceToast
+		});
+		const bulkUpdateMutation = useMutationWithTransition({
+			mutationFn: (vars) => {
+				if (!api.bulkUpdate) return Promise.reject(/* @__PURE__ */ new Error(`[arc-next] "${entityKey}" api does not define a bulkUpdate method`));
+				const auth = getAuthContext();
+				return api.bulkUpdate({
+					token: vars.token ?? auth.token,
+					organizationId: vars.organizationId ?? auth.organizationId,
+					filter: vars.filter,
+					data: vars.data
+				});
+			},
+			invalidateQueries: [KEYS.lists(), KEYS.details()],
+			messages: {
+				success: `${pluralName} updated successfully`,
+				error: `Failed to update ${pluralName.toLowerCase()}`
+			},
+			toastHandler: instanceToast
+		});
+		const bulkDeleteMutation = useMutationWithTransition({
+			mutationFn: (vars) => {
+				if (!api.bulkDelete) return Promise.reject(/* @__PURE__ */ new Error(`[arc-next] "${entityKey}" api does not define a bulkDelete method`));
+				const auth = getAuthContext();
+				return api.bulkDelete({
+					token: vars.token ?? auth.token,
+					organizationId: vars.organizationId ?? auth.organizationId,
+					filter: vars.filter
+				});
+			},
+			invalidateQueries: [KEYS.lists()],
+			messages: {
+				success: `${pluralName} deleted successfully`,
+				error: `Failed to delete ${pluralName.toLowerCase()}`
+			},
+			toastHandler: instanceToast
+		});
+		return {
+			bulkCreate: async (params, options) => {
+				const items = (await bulkCreateMutation.mutateAsync(params))?.data ?? [];
+				options?.onSuccess?.(items);
+				return items;
+			},
+			bulkUpdate: async (params, options) => {
+				const result = await bulkUpdateMutation.mutateAsync(params);
+				options?.onSuccess?.(result);
+				return result;
+			},
+			bulkRemove: async (params, options) => {
+				const result = await bulkDeleteMutation.mutateAsync(params);
+				options?.onSuccess?.(result);
+				return result;
+			},
+			isBulkCreating: bulkCreateMutation.isPending,
+			isBulkUpdating: bulkUpdateMutation.isPending,
+			isBulkDeleting: bulkDeleteMutation.isPending
+		};
+	}
 	const resolvedRouterHook = instanceNavigation ?? useRouterHook ?? (() => ({
 		push: () => {},
 		replace: () => {}
@@ -449,7 +739,7 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 		const queryClient = useQueryClient();
 		const router = resolvedRouterHook();
 		return useCallback((href, item, options = {}) => {
-			const id = getItemId(item);
+			const id = resolveItemId(item);
 			if (id) queryClient.setQueryData(KEYS.detail(id), { data: item });
 			if (!router) return;
 			const { scroll = true, replace = false } = options;
@@ -464,6 +754,12 @@ function createCrudHooks({ api, entityKey, singular, defaults = {}, callbacks =
 		useDetail,
 		useInfiniteList,
 		useActions,
+		useBulkActions,
+		useDeleted,
+		useDetailBySlug,
+		useTree,
+		useChildren,
+		useFindBy,
 		useUpload,
 		useSearch,
 		useCustomMutation,

package/dist/mutation.d.ts

@@ -1,5 +1,6 @@
 import { ToastHandler } from "./client.js";
-import * as _tanstack_react_query0 from "@tanstack/react-query";
+import { QUERY_CONFIGS } from "./query.js";
+import * as _$_tanstack_react_query0 from "@tanstack/react-query";
 import { QueryClient, QueryKey, UseMutateAsyncFunction, UseMutateFunction } from "@tanstack/react-query";
 
 //#region src/mutation.d.ts
@@ -47,8 +48,8 @@ interface TransitionMutationConfig<TData, TVariables> {
   toastHandler?: ToastHandler;
 }
 declare function useMutationWithTransition<TData, TVariables>(config: TransitionMutationConfig<TData, TVariables>): {
-  mutate: UseMutateFunction<TData, Error, TVariables, unknown>;
-  mutateAsync: UseMutateAsyncFunction<TData, Error, TVariables, unknown>;
+  mutate: UseMutateFunction<TData, Error, TVariables, void>;
+  mutateAsync: UseMutateAsyncFunction<TData, Error, TVariables, void>;
   isPending: boolean;
   isSuccess: boolean;
   isError: boolean;
@@ -100,27 +101,12 @@ interface CreateOptimisticMutationConfig<TData, TVariables> {
   shouldToast?: () => boolean;
   toastHandler?: ToastHandler;
 }
-declare function useOptimisticMutation<TData, TVariables>(config: CreateOptimisticMutationConfig<TData, TVariables>): _tanstack_react_query0.UseMutationResult<TData, Error, TVariables, {
+declare function useOptimisticMutation<TData, TVariables>(config: CreateOptimisticMutationConfig<TData, TVariables>): _$_tanstack_react_query0.UseMutationResult<TData, Error, TVariables, {
   previous: {
     key: readonly unknown[];
     data: [readonly unknown[], unknown][];
   }[];
 }>;
-declare const QUERY_CONFIGS: {
-  readonly realtime: {
-    readonly staleTime: 20000;
-    readonly refetchInterval: 30000;
-  };
-  readonly frequent: {
-    readonly staleTime: 60000;
-  };
-  readonly stable: {
-    readonly staleTime: 300000;
-  };
-  readonly static: {
-    readonly staleTime: 600000;
-  };
-};
 /** @deprecated Use `useOptimisticMutation` */
 declare const createOptimisticMutation: typeof useOptimisticMutation;
 //#endregion

package/dist/mutation.js

@@ -1,8 +1,9 @@
 "use client";
 
-import { isArcApiError } from "./client.js";
+import { isArcApiError, isAutoIdempotency } from "./client.js";
+import { QUERY_CONFIGS } from "./query.js";
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { useTransition } from "react";
+import { useCallback, useRef, useTransition } from "react";
 
 //#region src/mutation.ts
 let toastHandler = {
@@ -43,8 +44,18 @@ function useMutationWithTransition(config) {
 	const { mutationFn, invalidateQueries = [], onSuccess, onError, onSettled, messages, useTransition: withTransition = true, showToast: toast = true, toastHandler: instanceToast } = config;
 	const queryClient = useQueryClient();
 	const [isTransitioning, startTransition] = useTransition();
+	const idempotencyKeyRef = useRef(null);
 	const mutation = useMutation({
-		mutationFn,
+		mutationFn: (variables) => {
+			if (idempotencyKeyRef.current && typeof variables === "object" && variables !== null) {
+				const vars = variables;
+				if (vars.options && typeof vars.options === "object") vars.options.idempotencyKey ??= idempotencyKeyRef.current;
+			}
+			return mutationFn(variables);
+		},
+		onMutate: () => {
+			idempotencyKeyRef.current = isAutoIdempotency() ? globalThis.crypto.randomUUID() : null;
+		},
 		onSuccess: (data, variables) => {
 			const invalidate = () => {
 				invalidateQueries.forEach((key) => queryClient.invalidateQueries({ queryKey: key }));
@@ -151,15 +162,6 @@ function useOptimisticMutation(config) {
 		}
 	});
 }
-const QUERY_CONFIGS = {
-	realtime: {
-		staleTime: 2e4,
-		refetchInterval: 3e4
-	},
-	frequent: { staleTime: 6e4 },
-	stable: { staleTime: 3e5 },
-	static: { staleTime: 6e5 }
-};
 /** @deprecated Use `useOptimisticMutation` */
 const createOptimisticMutation = useOptimisticMutation;
 

package/dist/prefetch.d.ts

@@ -28,6 +28,21 @@ interface CrudPrefetcher {
    * await productsPrefetcher.prefetchDetail(queryClient, productId);
    */
   prefetchDetail: (queryClient: QueryClient, id: string, options?: PrefetchDetailOptions) => Promise<void>;
+  /**
+   * Prefetch a detail-by-slug query. Uses the same query keys as useDetailBySlug.
+   * Only available when the API has a `getBySlug` method (slugLookup preset).
+   */
+  prefetchBySlug: (queryClient: QueryClient, slug: string, options?: PrefetchDetailOptions) => Promise<void>;
+  /**
+   * Prefetch soft-deleted items. Uses the same query keys as useDeleted.
+   * Only available when the API has a `getDeleted` method (softDelete preset).
+   */
+  prefetchDeleted: (queryClient: QueryClient, params?: Record<string, unknown>, options?: PrefetchOptions) => Promise<void>;
+  /**
+   * Prefetch a tree query. Uses the same query keys as useTree.
+   * Only available when the API has a `getTree` method (tree preset).
+   */
+  prefetchTree: (queryClient: QueryClient, params?: Record<string, unknown>, options?: PrefetchOptions) => Promise<void>;
 }
 /**
  * Create server-safe prefetch helpers for CRUD queries.
@@ -65,6 +80,22 @@ declare function createCrudPrefetcher(api: {
     token?: string | null;
     organizationId?: string | null;
   }) => Promise<unknown>;
+  getBySlug?: (opts: {
+    slug: string;
+    token?: string | null;
+    organizationId?: string | null;
+    params?: Record<string, unknown>;
+  }) => Promise<unknown>;
+  getDeleted?: (opts: {
+    params?: Record<string, unknown>;
+    token?: string | null;
+    organizationId?: string | null;
+  }) => Promise<unknown>;
+  getTree?: (opts: {
+    params?: Record<string, unknown>;
+    token?: string | null;
+    organizationId?: string | null;
+  }) => Promise<unknown>;
 }, entityKey: string): CrudPrefetcher;
 //#endregion
 export { CrudPrefetcher, PrefetchDetailOptions, PrefetchOptions, createCrudPrefetcher, dehydrate };

package/dist/prefetch.js

@@ -1,23 +1,7 @@
+import { createQueryKeys } from "./query.js";
 import { dehydrate } from "@tanstack/react-query";
 
 //#region src/prefetch.ts
-function scopedListKey(entityKey, scope, params) {
-	return [
-		entityKey,
-		"list",
-		{
-			_scope: scope,
-			...params || {}
-		}
-	];
-}
-function detailKey(entityKey, id) {
-	return [
-		entityKey,
-		"detail",
-		id
-	];
-}
 /**
 * Create server-safe prefetch helpers for CRUD queries.
 * Use in Next.js server components to pre-populate the query cache before rendering.
@@ -44,10 +28,12 @@ function detailKey(entityKey, id) {
 * }
 */
 function createCrudPrefetcher(api, entityKey) {
+	const KEYS = createQueryKeys(entityKey);
 	return {
 		async prefetchList(queryClient, params = {}, options = {}) {
 			const { organizationId, ...restParams } = params;
-			const queryKey = scopedListKey(entityKey, organizationId ? "tenant" : "super-admin", {
+			const scope = organizationId ? "tenant" : "super-admin";
+			const queryKey = KEYS.scopedList(scope, {
 				organizationId,
 				...restParams
 			});
@@ -62,7 +48,7 @@ function createCrudPrefetcher(api, entityKey) {
 		},
 		async prefetchDetail(queryClient, id, options = {}) {
 			const { params, staleTime } = options;
-			const baseKey = detailKey(entityKey, id);
+			const baseKey = KEYS.detail(id);
 			const queryKey = params ? [...baseKey, params] : baseKey;
 			await queryClient.prefetchQuery({
 				queryKey,
@@ -72,6 +58,51 @@ function createCrudPrefetcher(api, entityKey) {
 				}),
 				staleTime
 			});
+		},
+		async prefetchBySlug(queryClient, slug, options = {}) {
+			if (!api.getBySlug) throw new Error(`[arc-next] prefetchBySlug requires an api with getBySlug (slugLookup preset)`);
+			const { params, staleTime } = options;
+			const queryKey = params ? KEYS.custom("slug", slug, params) : KEYS.custom("slug", slug);
+			await queryClient.prefetchQuery({
+				queryKey,
+				queryFn: () => api.getBySlug({
+					slug,
+					...params ? { params } : {}
+				}),
+				staleTime
+			});
+		},
+		async prefetchDeleted(queryClient, params = {}, options = {}) {
+			if (!api.getDeleted) throw new Error(`[arc-next] prefetchDeleted requires an api with getDeleted (softDelete preset)`);
+			const { organizationId, ...restParams } = params;
+			const queryKey = KEYS.custom("deleted", {
+				organizationId,
+				...restParams
+			});
+			await queryClient.prefetchQuery({
+				queryKey,
+				queryFn: () => api.getDeleted({
+					params: restParams,
+					organizationId: organizationId ?? null
+				}),
+				staleTime: options.staleTime
+			});
+		},
+		async prefetchTree(queryClient, params = {}, options = {}) {
+			if (!api.getTree) throw new Error(`[arc-next] prefetchTree requires an api with getTree (tree preset)`);
+			const { organizationId, ...restParams } = params;
+			const queryKey = KEYS.custom("tree", {
+				organizationId,
+				...restParams
+			});
+			await queryClient.prefetchQuery({
+				queryKey,
+				queryFn: () => api.getTree({
+					params: restParams,
+					organizationId: organizationId ?? null
+				}),
+				staleTime: options.staleTime
+			});
 		}
 	};
 }