@questpie/admin 1.1.1 → 3.0.0

package/dist/client/hooks/use-current-user.mjs

@@ -0,0 +1,79 @@
+import { useAuthClientSafe } from "./use-auth.mjs";
+import { c } from "react/compiler-runtime";
+
+//#region src/client/hooks/use-current-user.ts
+/**
+* Current User Hooks
+*
+* Convenience hooks for accessing the current user from Better Auth session.
+* These hooks use the authClient.useSession() internally.
+*
+* @example
+* ```tsx
+* function UserProfile() {
+*   const user = useCurrentUser();
+*   const isAdmin = useIsAdmin();
+*
+*   if (!user) return <LoginPrompt />;
+*
+*   return (
+*     <div>
+*       <h1>{user.name}</h1>
+*       {isAdmin && <AdminBadge />}
+*     </div>
+*   );
+* }
+* ```
+*/
+/**
+* Get the current authenticated user from session.
+*
+* Returns null if:
+* - No auth client is configured
+* - User is not authenticated
+* - Session is still loading (use useSessionState for loading state)
+*
+* @example
+* ```tsx
+* const user = useCurrentUser();
+* if (!user) return <LoginPage />;
+* return <div>Hello {user.name}</div>;
+* ```
+*/
+function useCurrentUser() {
+	const authClient = useAuthClientSafe();
+	if (!authClient) return null;
+	const { data: session } = authClient.useSession();
+	return session?.user ?? null;
+}
+/**
+* Get full session state including loading and error.
+*
+* @example
+* ```tsx
+* const { user, isPending, error } = useSessionState();
+*
+* if (isPending) return <Loading />;
+* if (error) return <Error message={error.message} />;
+* if (!user) return <LoginPage />;
+*
+* return <Dashboard user={user} />;
+* ```
+*/
+function useSessionState() {
+	const authClient = useAuthClientSafe();
+	if (!authClient) return {
+		user: null,
+		isPending: false,
+		error: null
+	};
+	const { data: session, isPending, error } = authClient.useSession();
+	return {
+		user: session?.user ?? null,
+		isPending,
+		error: error ?? null
+	};
+}
+
+//#endregion
+export { useCurrentUser, useSessionState };

package/dist/client/hooks/use-field-hooks.mjs

@@ -0,0 +1,199 @@
+import { trackDependencies } from "../utils/dependency-tracker.mjs";
+import * as React from "react";
+import { useQuery } from "@tanstack/react-query";
+import { useFormContext, useWatch } from "react-hook-form";
+
+//#region src/client/hooks/use-field-hooks.ts
+/**
+* Field Hooks
+*
+* React hooks for field-level compute, onChange handlers, and async options.
+* Uses Proxy-based dependency tracking for automatic reactivity.
+*
+* Best Practices:
+* - useWatch() hook for reactive form values (React pattern)
+* - form.getValues() only inside callbacks/effects (one-time reads)
+* - useMemo for computed values to avoid unnecessary recalculations
+*/
+function createHookContext(form, fieldName, locale) {
+	return {
+		fieldName,
+		locale,
+		setValue: (name, value) => {
+			form.setValue(name, value, {
+				shouldDirty: true,
+				shouldTouch: true,
+				shouldValidate: false
+			});
+		},
+		getValues: () => form.getValues(),
+		getValue: (name) => form.getValues(name)
+	};
+}
+/**
+* Hook for implementing field-level hooks (compute, onChange, loadOptions).
+* Uses Proxy-based dependency tracking for automatic reactivity.
+*
+* @example
+* ```tsx
+* const { handleChange, computedValue, isComputed, options, optionsLoading } = useFieldHooks({
+*   fieldName: 'pricePerMinute',
+*   fullFieldName: 'pricePerMinute',
+*   compute: (values) => values.price / values.duration,
+* });
+* ```
+*/
+function useFieldHooks({ fieldName, fullFieldName, locale, compute, onChange, defaultValue, loadOptions, staticOptions }) {
+	const form = useFormContext();
+	const [loadOptionsDeps, setLoadOptionsDeps] = React.useState([]);
+	const [computeDeps, setComputeDeps] = React.useState([]);
+	const hookCtx = React.useMemo(() => createHookContext(form, fieldName, locale), [
+		form,
+		fieldName,
+		locale
+	]);
+	React.useEffect(() => {
+		if (!compute) {
+			setComputeDeps([]);
+			return;
+		}
+		const tracked = trackDependencies(form.getValues() ?? {}, compute);
+		setComputeDeps([...new Set(tracked.deps)]);
+	}, [compute, form]);
+	React.useEffect(() => {
+		if (!loadOptions) {
+			setLoadOptionsDeps([]);
+			return;
+		}
+		const tracked_0 = trackDependencies(form.getValues() ?? {}, (proxyValues) => {
+			loadOptions(proxyValues);
+			return null;
+		});
+		setLoadOptionsDeps([...new Set(tracked_0.deps)]);
+	}, [loadOptions, form]);
+	const watchedDeps = React.useMemo(() => [...new Set([...computeDeps, ...loadOptionsDeps])], [computeDeps, loadOptionsDeps]);
+	const watchedDepValues = useWatch({
+		control: form.control,
+		name: watchedDeps,
+		disabled: watchedDeps.length === 0
+	});
+	const watchedDepMap = React.useMemo(() => {
+		const depMap = {};
+		if (watchedDeps.length === 0) return depMap;
+		const values_1 = Array.isArray(watchedDepValues) ? watchedDepValues : [watchedDepValues];
+		for (const [index, dep] of watchedDeps.entries()) depMap[dep] = values_1[index];
+		return depMap;
+	}, [watchedDeps, watchedDepValues]);
+	const computeDepKey = React.useMemo(() => {
+		if (!computeDeps.length) return "";
+		return JSON.stringify(computeDeps.map((dep_0) => watchedDepMap[dep_0]));
+	}, [computeDeps, watchedDepMap]);
+	const computedValue = React.useMemo(() => {
+		if (!compute) return void 0;
+		try {
+			return compute(form.getValues() ?? {});
+		} catch (error) {
+			console.error(`Compute error for ${fieldName}:`, error);
+			return;
+		}
+	}, [
+		compute,
+		form,
+		fieldName,
+		computeDepKey
+	]);
+	const defaultValueInitialized = React.useRef(false);
+	React.useEffect(() => {
+		if (defaultValueInitialized.current) return;
+		if (defaultValue === void 0) return;
+		if (compute) {
+			defaultValueInitialized.current = true;
+			return;
+		}
+		const currentValue = form.getValues(fullFieldName);
+		if (currentValue !== void 0 && currentValue !== null) {
+			defaultValueInitialized.current = true;
+			return;
+		}
+		const initDefaultValue = async () => {
+			let resolvedValue;
+			if (typeof defaultValue === "function") {
+				const values_3 = form.getValues();
+				resolvedValue = await Promise.resolve(defaultValue(values_3));
+			} else resolvedValue = defaultValue;
+			const currentVal = form.getValues(fullFieldName);
+			if (currentVal === void 0 || currentVal === null) form.setValue(fullFieldName, resolvedValue, {
+				shouldDirty: false,
+				shouldTouch: false
+			});
+			defaultValueInitialized.current = true;
+		};
+		initDefaultValue();
+	}, [
+		defaultValue,
+		fullFieldName,
+		form,
+		compute
+	]);
+	const { data: asyncOptions, isLoading: optionsLoading } = useQuery({
+		queryKey: [
+			"questpie",
+			"field-hooks-options",
+			fieldName,
+			React.useMemo(() => {
+				if (!loadOptionsDeps.length) return "";
+				return JSON.stringify(loadOptionsDeps.map((dep_1) => watchedDepMap[dep_1]));
+			}, [loadOptionsDeps, watchedDepMap])
+		],
+		queryFn: async () => {
+			if (!loadOptions) return [];
+			return loadOptions(form.getValues() ?? {});
+		},
+		enabled: !!loadOptions && loadOptionsDeps.length > 0,
+		staleTime: 3e4,
+		placeholderData: (prev) => prev
+	});
+	const handleChange = React.useCallback((value) => {
+		if (compute) return;
+		form.setValue(fullFieldName, value, {
+			shouldDirty: true,
+			shouldTouch: true,
+			shouldValidate: false
+		});
+		if (onChange) {
+			const runOnChange = async () => {
+				try {
+					await Promise.resolve(onChange(value, hookCtx));
+				} catch (error_0) {
+					console.error(`onChange error for ${fieldName}:`, error_0);
+				}
+			};
+			runOnChange();
+		}
+	}, [
+		form,
+		fullFieldName,
+		onChange,
+		hookCtx,
+		fieldName,
+		compute
+	]);
+	const options = React.useMemo(() => {
+		if (loadOptions) return asyncOptions;
+		return staticOptions;
+	}, [
+		loadOptions,
+		asyncOptions,
+		staticOptions
+	]);
+	return {
+		handleChange,
+		computedValue,
+		isComputed: !!compute,
+		options,
+		optionsLoading
+	};
+}
+
+//#endregion
+export { useFieldHooks };

package/dist/client/hooks/use-field-options.d.mts

@@ -0,0 +1,57 @@
+import { SerializedOptionsConfig } from "questpie";
+
+//#region src/client/hooks/use-field-options.d.ts
+interface OptionItem {
+  value: string | number;
+  label: string | Record<string, string>;
+}
+interface UseFieldOptionsOptions {
+  /** Collection or global name */
+  collection: string;
+  /** Entity type - collection or global */
+  mode?: "collection" | "global";
+  /** Field path */
+  field: string;
+  /** Options config from introspection */
+  optionsConfig?: SerializedOptionsConfig;
+  /** Static options (fallback if no dynamic config) */
+  staticOptions?: OptionItem[];
+  /** Initial search query */
+  initialSearch?: string;
+  /** Items per page */
+  limit?: number;
+  /** Whether to enable fetching */
+  enabled?: boolean;
+}
+interface UseFieldOptionsResult {
+  /** Current options */
+  options: OptionItem[];
+  /** Whether options are loading */
+  isLoading: boolean;
+  /** Whether more options are available */
+  hasMore: boolean;
+  /** Total count (if available) */
+  total?: number;
+  /** Current search query */
+  search: string;
+  /** Set search query */
+  setSearch: (search: string) => void;
+  /** Load more options (pagination) */
+  loadMore: () => void;
+  /** Refresh options */
+  refresh: () => void;
+  /** Error */
+  error: Error | null;
+}
+declare function useFieldOptions({
+  collection,
+  mode,
+  field,
+  optionsConfig,
+  staticOptions,
+  initialSearch,
+  limit,
+  enabled
+}: UseFieldOptionsOptions): UseFieldOptionsResult;
+//#endregion
+export { OptionItem, UseFieldOptionsOptions, UseFieldOptionsResult, useFieldOptions };

package/dist/client/hooks/use-field-options.mjs

@@ -0,0 +1,269 @@
+import { useAdminStore } from "../runtime/provider.mjs";
+import { useDebouncedValue } from "./use-search.mjs";
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+import { useInfiniteQuery, useQueryClient } from "@tanstack/react-query";
+import { useFormContext, useWatch } from "react-hook-form";
+
+//#region src/client/hooks/use-field-options.ts
+function getSiblingData(values, fieldPath) {
+	const parts = fieldPath.split(".");
+	const numericIndex = parts.findIndex((p) => /^\d+$/.test(p));
+	if (numericIndex === -1) return null;
+	const arrayItemPath = parts.slice(0, numericIndex + 1).join(".");
+	let sibling = values;
+	for (const part of arrayItemPath.split(".")) if (sibling && typeof sibling === "object") sibling = sibling[part];
+	else return null;
+	return typeof sibling === "object" ? sibling : null;
+}
+function getWatchedValues(allValues, siblingData, watchDeps) {
+	const result = {};
+	for (const dep of watchDeps) if (dep.startsWith("$sibling.")) {
+		const siblingKey = dep.slice(9);
+		result[dep] = siblingData?.[siblingKey];
+	} else if (!dep.startsWith("$")) result[dep] = allValues[dep];
+	return result;
+}
+function useFieldOptions(t0) {
+	const $ = c(57);
+	const { collection, mode: t1, field, optionsConfig, staticOptions, initialSearch: t2, limit: t3, enabled: t4 } = t0;
+	const mode = t1 === void 0 ? "collection" : t1;
+	const initialSearch = t2 === void 0 ? "" : t2;
+	const limit = t3 === void 0 ? 20 : t3;
+	const enabled = t4 === void 0 ? true : t4;
+	const client = useAdminStore(_temp);
+	const form = useFormContext();
+	const queryClient = useQueryClient();
+	const [search, setSearch] = React.useState(initialSearch);
+	const debouncedSearch = useDebouncedValue(search, 300);
+	let t5;
+	if ($[0] !== form.control) {
+		t5 = { control: form.control };
+		$[0] = form.control;
+		$[1] = t5;
+	} else t5 = $[1];
+	const watchedValues = useWatch(t5);
+	let t6;
+	if ($[2] !== watchedValues) {
+		t6 = watchedValues ?? {};
+		$[2] = watchedValues;
+		$[3] = t6;
+	} else t6 = $[3];
+	const formValues = t6;
+	let t7;
+	if ($[4] !== field || $[5] !== formValues) {
+		t7 = getSiblingData(formValues, field);
+		$[4] = field;
+		$[5] = formValues;
+		$[6] = t7;
+	} else t7 = $[6];
+	const siblingData = t7;
+	let t8;
+	if ($[7] !== optionsConfig?.watch) {
+		t8 = optionsConfig?.watch ?? [];
+		$[7] = optionsConfig?.watch;
+		$[8] = t8;
+	} else t8 = $[8];
+	const watchDeps = t8;
+	let t9;
+	if ($[9] !== formValues || $[10] !== siblingData || $[11] !== watchDeps) {
+		t9 = getWatchedValues(formValues, siblingData, watchDeps);
+		$[9] = formValues;
+		$[10] = siblingData;
+		$[11] = watchDeps;
+		$[12] = t9;
+	} else t9 = $[12];
+	const depValues = t9;
+	let t10;
+	if ($[13] !== depValues) {
+		t10 = JSON.stringify(depValues);
+		$[13] = depValues;
+		$[14] = t10;
+	} else t10 = $[14];
+	const depKey = t10;
+	let t11;
+	bb0: {
+		if (optionsConfig || !staticOptions) {
+			t11 = null;
+			break bb0;
+		}
+		if (!debouncedSearch) {
+			t11 = staticOptions;
+			break bb0;
+		}
+		let t12$1;
+		if ($[15] !== debouncedSearch || $[16] !== staticOptions) {
+			const searchLower = debouncedSearch.toLowerCase();
+			t12$1 = staticOptions.filter((opt) => {
+				return (typeof opt.label === "string" ? opt.label : Object.values(opt.label).join(" ")).toLowerCase().includes(searchLower);
+			});
+			$[15] = debouncedSearch;
+			$[16] = staticOptions;
+			$[17] = t12$1;
+		} else t12$1 = $[17];
+		t11 = t12$1;
+	}
+	const filteredStaticOptions = t11;
+	let t12;
+	if ($[18] !== collection || $[19] !== debouncedSearch || $[20] !== depKey || $[21] !== field || $[22] !== mode) {
+		t12 = [
+			"questpie",
+			"field-options",
+			collection,
+			mode,
+			field,
+			debouncedSearch,
+			depKey
+		];
+		$[18] = collection;
+		$[19] = debouncedSearch;
+		$[20] = depKey;
+		$[21] = field;
+		$[22] = mode;
+		$[23] = t12;
+	} else t12 = $[23];
+	let t13;
+	if ($[24] !== client || $[25] !== collection || $[26] !== debouncedSearch || $[27] !== field || $[28] !== form || $[29] !== limit || $[30] !== mode) {
+		t13 = async (t14$1) => {
+			const { pageParam: t15$1 } = t14$1;
+			const pageParam = t15$1 === void 0 ? 0 : t15$1;
+			const currentFormValues = form.getValues() ?? {};
+			const currentSiblingData = getSiblingData(currentFormValues, field);
+			const response = await client.routes.fieldOptions({
+				collection,
+				type: mode,
+				field,
+				formData: currentFormValues,
+				siblingData: currentSiblingData,
+				search: debouncedSearch,
+				page: pageParam,
+				limit
+			});
+			return {
+				options: response.options,
+				hasMore: response.hasMore ?? false,
+				total: response.total,
+				page: pageParam
+			};
+		};
+		$[24] = client;
+		$[25] = collection;
+		$[26] = debouncedSearch;
+		$[27] = field;
+		$[28] = form;
+		$[29] = limit;
+		$[30] = mode;
+		$[31] = t13;
+	} else t13 = $[31];
+	const t14 = enabled && !!optionsConfig && !!client;
+	let t15;
+	if ($[32] !== t12 || $[33] !== t13 || $[34] !== t14) {
+		t15 = {
+			queryKey: t12,
+			queryFn: t13,
+			initialPageParam: 0,
+			getNextPageParam: _temp2,
+			enabled: t14,
+			staleTime: 1e4,
+			placeholderData: _temp3
+		};
+		$[32] = t12;
+		$[33] = t13;
+		$[34] = t14;
+		$[35] = t15;
+	} else t15 = $[35];
+	const { data, isLoading: queryLoading, error: queryError, fetchNextPage, hasNextPage, isFetchingNextPage } = useInfiniteQuery(t15);
+	let t16;
+	bb1: {
+		if (!data) {
+			let t17$2;
+			if ($[36] === Symbol.for("react.memo_cache_sentinel")) {
+				t17$2 = [];
+				$[36] = t17$2;
+			} else t17$2 = $[36];
+			t16 = t17$2;
+			break bb1;
+		}
+		let t17$1;
+		if ($[37] !== data.pages) {
+			t17$1 = data.pages.flatMap(_temp4);
+			$[37] = data.pages;
+			$[38] = t17$1;
+		} else t17$1 = $[38];
+		t16 = t17$1;
+	}
+	const serverOptions = t16;
+	const total = data?.pages[data.pages.length - 1]?.total;
+	const options = filteredStaticOptions ?? serverOptions;
+	const isLoading = filteredStaticOptions ? false : queryLoading;
+	const hasMore = filteredStaticOptions ? false : hasNextPage ?? false;
+	let t17;
+	if ($[39] !== fetchNextPage || $[40] !== hasNextPage || $[41] !== isFetchingNextPage) {
+		t17 = () => {
+			if (!isFetchingNextPage && hasNextPage) fetchNextPage();
+		};
+		$[39] = fetchNextPage;
+		$[40] = hasNextPage;
+		$[41] = isFetchingNextPage;
+		$[42] = t17;
+	} else t17 = $[42];
+	const loadMore = t17;
+	let t18;
+	if ($[43] !== collection || $[44] !== field || $[45] !== mode || $[46] !== queryClient) {
+		t18 = () => {
+			queryClient.invalidateQueries({ queryKey: [
+				"questpie",
+				"field-options",
+				collection,
+				mode,
+				field
+			] });
+		};
+		$[43] = collection;
+		$[44] = field;
+		$[45] = mode;
+		$[46] = queryClient;
+		$[47] = t18;
+	} else t18 = $[47];
+	const refresh = t18;
+	const t19 = queryError ?? null;
+	let t20;
+	if ($[48] !== hasMore || $[49] !== isLoading || $[50] !== loadMore || $[51] !== options || $[52] !== refresh || $[53] !== search || $[54] !== t19 || $[55] !== total) {
+		t20 = {
+			options,
+			isLoading,
+			hasMore,
+			total,
+			search,
+			setSearch,
+			loadMore,
+			refresh,
+			error: t19
+		};
+		$[48] = hasMore;
+		$[49] = isLoading;
+		$[50] = loadMore;
+		$[51] = options;
+		$[52] = refresh;
+		$[53] = search;
+		$[54] = t19;
+		$[55] = total;
+		$[56] = t20;
+	} else t20 = $[56];
+	return t20;
+}
+function _temp4(page) {
+	return page.options;
+}
+function _temp3(prev) {
+	return prev;
+}
+function _temp2(lastPage) {
+	return lastPage.hasMore ? lastPage.page + 1 : void 0;
+}
+function _temp(s) {
+	return s.client;
+}
+
+//#endregion
+export { useFieldOptions };

package/dist/client/hooks/use-global-fields.mjs

@@ -0,0 +1,58 @@
+import { selectAdmin, useAdminStore } from "../runtime/provider.mjs";
+import { buildFieldDefinitionsFromSchema } from "../utils/build-field-definitions-from-schema.mjs";
+import { useGlobalSchema } from "./use-global-schema.mjs";
+import { c } from "react/compiler-runtime";
+
+//#region src/client/hooks/use-global-fields.ts
+function useGlobalFields(globalName, t0) {
+	const $ = c(12);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const options = t1;
+	const admin = useAdminStore(selectAdmin);
+	const { data: schema, isLoading, error } = useGlobalSchema(globalName, options.schemaQueryOptions);
+	let t2;
+	bb0: {
+		if (!schema || !admin) {
+			let t3$2;
+			if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+				t3$2 = {};
+				$[2] = t3$2;
+			} else t3$2 = $[2];
+			t2 = t3$2;
+			break bb0;
+		}
+		let t3$1;
+		if ($[3] !== admin || $[4] !== options.buildOptions || $[5] !== schema) {
+			t3$1 = buildFieldDefinitionsFromSchema(schema, admin.getFields(), options.buildOptions);
+			$[3] = admin;
+			$[4] = options.buildOptions;
+			$[5] = schema;
+			$[6] = t3$1;
+		} else t3$1 = $[6];
+		t2 = t3$1;
+	}
+	const fields = t2;
+	let t3;
+	if ($[7] !== error || $[8] !== fields || $[9] !== isLoading || $[10] !== schema) {
+		t3 = {
+			fields,
+			schema,
+			isLoading,
+			error
+		};
+		$[7] = error;
+		$[8] = fields;
+		$[9] = isLoading;
+		$[10] = schema;
+		$[11] = t3;
+	} else t3 = $[11];
+	return t3;
+}
+
+//#endregion
+export { useGlobalFields };