@questpie/admin 1.1.1 → 3.0.0

package/dist/client/hooks/use-server-validation.mjs

@@ -0,0 +1,291 @@
+import { useCollectionSchema } from "./use-collection-schema.mjs";
+import { useGlobalSchema } from "./use-global-schema.mjs";
+import { c } from "react/compiler-runtime";
+import { ajvResolver } from "@hookform/resolvers/ajv";
+
+//#region src/client/hooks/use-server-validation.ts
+/**
+* useServerValidation Hook
+*
+* Creates a react-hook-form resolver using the server's JSON Schema.
+* Uses AJV for validation, ensuring client-side validation matches server-side exactly.
+*
+* This hook fetches the collection schema from the server and uses the
+* `validation.insert` or `validation.update` JSON Schema for form validation.
+*/
+/**
+* Recursively strip `additionalProperties: false` and `$schema` from a JSON Schema.
+*
+* Zod's `z.toJSONSchema()` sets `additionalProperties: false` on every object,
+* which causes AJV to reject form data containing extra fields such as `id`,
+* `createdAt`, `updatedAt`, etc. that are part of the loaded document but not
+* in the validation schema.
+*
+* It also sets `$schema: "https://json-schema.org/draft/2020-12/schema"` which
+* is not supported by @hookform/resolvers/ajv out of the box.
+*/
+function stripAdditionalProperties(schema) {
+	if (!schema || typeof schema !== "object") return schema;
+	const s = { ...schema };
+	delete s.additionalProperties;
+	delete s.$schema;
+	if (s.properties && typeof s.properties === "object") {
+		const props = {};
+		for (const [k, v] of Object.entries(s.properties)) props[k] = stripAdditionalProperties(v);
+		s.properties = props;
+	}
+	if (s.items) s.items = stripAdditionalProperties(s.items);
+	return s;
+}
+/**
+* Hook to create a react-hook-form resolver using server's JSON Schema
+*
+* Uses the collection's validation schema from the server for client-side
+* validation, ensuring validation rules are consistent between client and server.
+*
+* @param collection - Collection name
+* @param options - Validation options
+* @returns Server validation result with resolver
+*
+* @example
+* ```tsx
+* function CreatePostForm() {
+*   const { resolver, isLoading } = useServerValidation("posts", { mode: "create" });
+*
+*   const form = useForm({
+*     resolver,
+*   });
+*
+*   if (isLoading) return <Loading />;
+*
+*   return <Form {...form}>...</Form>;
+* }
+* ```
+*
+* @example
+* ```tsx
+* // With fallback to client-side validation
+* function PostForm({ isEditing }) {
+*   const { resolver: serverResolver, hasServerSchema } = useServerValidation(
+*     "posts",
+*     { mode: isEditing ? "update" : "create" }
+*   );
+*   const clientResolver = useCollectionValidation("posts");
+*
+*   // Prefer server validation, fall back to client
+*   const resolver = hasServerSchema ? serverResolver : clientResolver;
+*
+*   const form = useForm({ resolver });
+* }
+* ```
+*/
+function useServerValidation(collection, t0) {
+	const $ = c(17);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { mode: t2, enabled: t3 } = t1;
+	const mode = t2 === void 0 ? "create" : t2;
+	const enabled = t3 === void 0 ? true : t3;
+	let t4;
+	if ($[2] !== enabled) {
+		t4 = { enabled };
+		$[2] = enabled;
+		$[3] = t4;
+	} else t4 = $[3];
+	const { data: schema, isLoading, error } = useCollectionSchema(collection, t4);
+	let t5;
+	if ($[4] !== collection || $[5] !== error || $[6] !== isLoading || $[7] !== mode || $[8] !== schema?.validation?.insert || $[9] !== schema?.validation?.update) {
+		bb0: {
+			const jsonSchema = stripAdditionalProperties(mode === "create" ? schema?.validation?.insert : schema?.validation?.update);
+			if (!jsonSchema || typeof jsonSchema !== "object") {
+				const t6 = error ?? null;
+				let t7;
+				if ($[11] !== isLoading || $[12] !== t6) {
+					t7 = {
+						resolver: void 0,
+						hasServerSchema: false,
+						isLoading,
+						error: t6
+					};
+					$[11] = isLoading;
+					$[12] = t6;
+					$[13] = t7;
+				} else t7 = $[13];
+				t5 = t7;
+				break bb0;
+			}
+			try {
+				const resolver = ajvResolver(jsonSchema, {
+					allErrors: true,
+					strict: false,
+					coerceTypes: true,
+					useDefaults: true,
+					formats: {}
+				}, { mode: "async" });
+				let t7;
+				if ($[14] !== resolver) {
+					t7 = {
+						resolver,
+						hasServerSchema: true,
+						isLoading: false,
+						error: null
+					};
+					$[14] = resolver;
+					$[15] = t7;
+				} else t7 = $[15];
+				t5 = t7;
+			} catch (t6) {
+				const e = t6;
+				console.warn(`[useServerValidation] Failed to compile JSON Schema for ${collection}:`, e);
+				let t7;
+				if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+					t7 = {
+						resolver: void 0,
+						hasServerSchema: false,
+						isLoading: false,
+						error: e instanceof Error ? e : new Error(String(e))
+					};
+					$[16] = t7;
+				} else t7 = $[16];
+				t5 = t7;
+			}
+		}
+		$[4] = collection;
+		$[5] = error;
+		$[6] = isLoading;
+		$[7] = mode;
+		$[8] = schema?.validation?.insert;
+		$[9] = schema?.validation?.update;
+		$[10] = t5;
+	} else t5 = $[10];
+	return t5;
+}
+/**
+* Hook to get a combined resolver that prefers server validation
+*
+* This is a convenience hook that combines server and client validation,
+* preferring server validation when available.
+*
+* @param collection - Collection name
+* @param options - Validation options
+* @param fallbackResolver - Optional client-side resolver to use as fallback
+* @returns Resolver function for react-hook-form
+*
+* @example
+* ```tsx
+* function PostForm({ isEditing }) {
+*   const clientResolver = useCollectionValidation("posts");
+*   const resolver = usePreferServerValidation("posts", {
+*     mode: isEditing ? "update" : "create"
+*   }, clientResolver);
+*
+*   const form = useForm({ resolver });
+* }
+* ```
+*/
+function usePreferServerValidation(collection, t0, fallbackResolver) {
+	const $ = c(2);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { resolver: serverResolver, hasServerSchema } = useServerValidation(collection, t1);
+	return hasServerSchema ? serverResolver : fallbackResolver;
+}
+/**
+* Hook to create a react-hook-form resolver for global settings using server's JSON Schema
+*
+* @param globalName - Global name
+* @param options - Validation options (mode is always "update" for globals)
+* @returns Server validation result with resolver
+*/
+function useGlobalServerValidation(globalName, t0) {
+	const $ = c(15);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { enabled: t2 } = t1;
+	const enabled = t2 === void 0 ? true : t2;
+	let t3;
+	if ($[2] !== enabled) {
+		t3 = { enabled };
+		$[2] = enabled;
+		$[3] = t3;
+	} else t3 = $[3];
+	const { data: schema, isLoading, error } = useGlobalSchema(globalName, t3);
+	let t4;
+	if ($[4] !== error || $[5] !== globalName || $[6] !== isLoading || $[7] !== schema?.validation?.update) {
+		bb0: {
+			const jsonSchema = stripAdditionalProperties(schema?.validation?.update);
+			if (!jsonSchema || typeof jsonSchema !== "object") {
+				const t5 = error ?? null;
+				let t6;
+				if ($[9] !== isLoading || $[10] !== t5) {
+					t6 = {
+						resolver: void 0,
+						hasServerSchema: false,
+						isLoading,
+						error: t5
+					};
+					$[9] = isLoading;
+					$[10] = t5;
+					$[11] = t6;
+				} else t6 = $[11];
+				t4 = t6;
+				break bb0;
+			}
+			try {
+				const resolver = ajvResolver(jsonSchema, {
+					allErrors: true,
+					strict: false,
+					coerceTypes: true,
+					useDefaults: true
+				}, { mode: "async" });
+				let t6;
+				if ($[12] !== resolver) {
+					t6 = {
+						resolver,
+						hasServerSchema: true,
+						isLoading: false,
+						error: null
+					};
+					$[12] = resolver;
+					$[13] = t6;
+				} else t6 = $[13];
+				t4 = t6;
+			} catch (t5) {
+				const e = t5;
+				console.warn(`[useGlobalServerValidation] Failed to compile JSON Schema for ${globalName}:`, e);
+				let t6;
+				if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
+					t6 = {
+						resolver: void 0,
+						hasServerSchema: false,
+						isLoading: false,
+						error: e instanceof Error ? e : new Error(String(e))
+					};
+					$[14] = t6;
+				} else t6 = $[14];
+				t4 = t6;
+			}
+		}
+		$[4] = error;
+		$[5] = globalName;
+		$[6] = isLoading;
+		$[7] = schema?.validation?.update;
+		$[8] = t4;
+	} else t4 = $[8];
+	return t4;
+}
+
+//#endregion
+export { useGlobalServerValidation, usePreferServerValidation };

package/dist/client/hooks/use-server-widget-data.d.mts

@@ -0,0 +1,25 @@
+import { UseQueryResult } from "@tanstack/react-query";
+
+//#region src/client/hooks/use-server-widget-data.d.ts
+
+/**
+ * Fetches widget data from server via the fetchWidgetData RPC endpoint.
+ *
+ * @param widgetId - The widget ID to fetch data for
+ * @param options - Query options
+ * @returns TanStack Query result with the widget data
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useServerWidgetData<{ count: number }>(
+ *   "my-widget",
+ *   { enabled: config.hasLoader }
+ * );
+ * ```
+ */
+declare function useServerWidgetData<T = unknown>(widgetId: string, options?: {
+  enabled?: boolean;
+  refreshInterval?: number;
+}): UseQueryResult<T>;
+//#endregion
+export { useServerWidgetData };

package/dist/client/hooks/use-server-widget-data.mjs

@@ -0,0 +1,65 @@
+import { selectClient, useAdminStore } from "../runtime/provider.mjs";
+import { c } from "react/compiler-runtime";
+import { useQuery } from "@tanstack/react-query";
+
+//#region src/client/hooks/use-server-widget-data.ts
+/**
+* Hook for fetching widget data from server via fetchWidgetData RPC.
+* Used when a widget has hasLoader=true (server-side loader).
+*/
+/**
+* Fetches widget data from server via the fetchWidgetData RPC endpoint.
+*
+* @param widgetId - The widget ID to fetch data for
+* @param options - Query options
+* @returns TanStack Query result with the widget data
+*
+* @example
+* ```tsx
+* const { data, isLoading } = useServerWidgetData<{ count: number }>(
+*   "my-widget",
+*   { enabled: config.hasLoader }
+* );
+* ```
+*/
+function useServerWidgetData(widgetId, options) {
+	const $ = c(10);
+	const client = useAdminStore(selectClient);
+	let t0;
+	if ($[0] !== widgetId) {
+		t0 = [
+			"widget",
+			"serverData",
+			widgetId
+		];
+		$[0] = widgetId;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== client || $[3] !== widgetId) {
+		t1 = () => client.routes.fetchWidgetData({ widgetId });
+		$[2] = client;
+		$[3] = widgetId;
+		$[4] = t1;
+	} else t1 = $[4];
+	const t2 = options?.enabled ?? true;
+	const t3 = options?.refreshInterval;
+	let t4;
+	if ($[5] !== t0 || $[6] !== t1 || $[7] !== t2 || $[8] !== t3) {
+		t4 = {
+			queryKey: t0,
+			queryFn: t1,
+			enabled: t2,
+			refetchInterval: t3
+		};
+		$[5] = t0;
+		$[6] = t1;
+		$[7] = t2;
+		$[8] = t3;
+		$[9] = t4;
+	} else t4 = $[9];
+	return useQuery(t4);
+}
+
+//#endregion
+export { useServerWidgetData };

package/dist/client/hooks/use-setup-status.d.mts

@@ -0,0 +1,38 @@
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+
+//#region src/client/hooks/use-setup-status.d.ts
+
+/**
+ * Setup Status Hook
+ *
+ * Hook to check if the app setup is required (no users exist).
+ * Useful for redirecting to setup page on first visit.
+ */
+interface SetupStatus {
+  /** Whether setup is required (no users exist) */
+  required: boolean;
+}
+/**
+ * Check if setup is required.
+ *
+ * Returns `required: true` if no users exist in the system,
+ * meaning the setup page should be shown to create the first admin.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { data, isLoading } = useSetupStatus();
+ *
+ *   if (isLoading) return <LoadingSpinner />;
+ *
+ *   if (data?.required) {
+ *     return <Navigate to="/admin/setup" />;
+ *   }
+ *
+ *   return <AdminPanel />;
+ * }
+ * ```
+ */
+declare function useSetupStatus(): _tanstack_react_query0.UseQueryResult<SetupStatus, Error>;
+//#endregion
+export { SetupStatus, useSetupStatus };

package/dist/client/hooks/use-setup-status.mjs

@@ -0,0 +1,62 @@
+import { selectClient, useAdminStore } from "../runtime/provider.mjs";
+import { c } from "react/compiler-runtime";
+import { useQuery } from "@tanstack/react-query";
+
+//#region src/client/hooks/use-setup-status.ts
+/**
+* Setup Status Hook
+*
+* Hook to check if the app setup is required (no users exist).
+* Useful for redirecting to setup page on first visit.
+*/
+/**
+* Check if setup is required.
+*
+* Returns `required: true` if no users exist in the system,
+* meaning the setup page should be shown to create the first admin.
+*
+* @example
+* ```tsx
+* function App() {
+*   const { data, isLoading } = useSetupStatus();
+*
+*   if (isLoading) return <LoadingSpinner />;
+*
+*   if (data?.required) {
+*     return <Navigate to="/admin/setup" />;
+*   }
+*
+*   return <AdminPanel />;
+* }
+* ```
+*/
+function useSetupStatus() {
+	const $ = c(3);
+	const client = useAdminStore(selectClient);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = ["questpie", "setup-status"];
+		$[0] = t0;
+	} else t0 = $[0];
+	let t1;
+	if ($[1] !== client) {
+		t1 = {
+			queryKey: t0,
+			queryFn: async () => {
+				try {
+					return { required: (await client.routes.isSetupRequired({})).required };
+				} catch {
+					return { required: false };
+				}
+			},
+			staleTime: 6e4,
+			retry: false
+		};
+		$[1] = client;
+		$[2] = t1;
+	} else t1 = $[2];
+	return useQuery(t1);
+}
+
+//#endregion
+export { useSetupStatus };

package/dist/client/hooks/use-sidebar-search-param.d.mts

@@ -0,0 +1,9 @@
+//#region src/client/hooks/use-sidebar-search-param.d.ts
+interface UseSidebarSearchParamOptions {
+  paramKey?: string;
+  legacyKey?: string;
+  legacyTrueValue?: string;
+}
+declare function useSidebarSearchParam(sidebarId: string, options?: UseSidebarSearchParamOptions): readonly [boolean, (next: boolean | ((prev: boolean) => boolean)) => void];
+//#endregion
+export { useSidebarSearchParam };

package/dist/client/hooks/use-sidebar-search-param.mjs

@@ -0,0 +1,104 @@
+import { SEARCH_PARAMS_EVENT } from "../lib/events.mjs";
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+
+//#region src/client/hooks/use-sidebar-search-param.ts
+function isTruthyParam(value, trueValue) {
+	if (value === null) return false;
+	if (value === trueValue) return true;
+	if (value === "true" || value === "1") return true;
+	return false;
+}
+function readSidebarOpen(sidebarId, paramKey, legacyKey, legacyTrueValue = "true") {
+	if (typeof window === "undefined") return false;
+	const params = new URLSearchParams(window.location.search);
+	if (params.get(paramKey) === sidebarId) return true;
+	if (legacyKey) return isTruthyParam(params.get(legacyKey), legacyTrueValue);
+	return false;
+}
+function useSidebarSearchParam(sidebarId, t0) {
+	const $ = c(20);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const options = t1;
+	const paramKey = options.paramKey ?? "sidebar";
+	const legacyKey = options.legacyKey;
+	const legacyTrueValue = options.legacyTrueValue ?? "true";
+	let t2;
+	if ($[2] !== legacyKey || $[3] !== legacyTrueValue || $[4] !== paramKey || $[5] !== sidebarId) {
+		t2 = () => readSidebarOpen(sidebarId, paramKey, legacyKey, legacyTrueValue);
+		$[2] = legacyKey;
+		$[3] = legacyTrueValue;
+		$[4] = paramKey;
+		$[5] = sidebarId;
+		$[6] = t2;
+	} else t2 = $[6];
+	const [open, setOpenState] = React.useState(t2);
+	let t3;
+	let t4;
+	if ($[7] !== legacyKey || $[8] !== legacyTrueValue || $[9] !== paramKey || $[10] !== sidebarId) {
+		t3 = () => {
+			const syncFromUrl = () => {
+				setOpenState(readSidebarOpen(sidebarId, paramKey, legacyKey, legacyTrueValue));
+			};
+			window.addEventListener("popstate", syncFromUrl);
+			window.addEventListener(SEARCH_PARAMS_EVENT, syncFromUrl);
+			return () => {
+				window.removeEventListener("popstate", syncFromUrl);
+				window.removeEventListener(SEARCH_PARAMS_EVENT, syncFromUrl);
+			};
+		};
+		t4 = [
+			sidebarId,
+			paramKey,
+			legacyKey,
+			legacyTrueValue
+		];
+		$[7] = legacyKey;
+		$[8] = legacyTrueValue;
+		$[9] = paramKey;
+		$[10] = sidebarId;
+		$[11] = t3;
+		$[12] = t4;
+	} else {
+		t3 = $[11];
+		t4 = $[12];
+	}
+	React.useEffect(t3, t4);
+	let t5;
+	if ($[13] !== legacyKey || $[14] !== paramKey || $[15] !== sidebarId) {
+		t5 = (next) => {
+			setOpenState((prev) => {
+				const resolved = typeof next === "function" ? next(prev) : next;
+				if (typeof window === "undefined") return resolved;
+				const url = new URL(window.location.href);
+				if (resolved) url.searchParams.set(paramKey, sidebarId);
+				else if (url.searchParams.get(paramKey) === sidebarId) url.searchParams.delete(paramKey);
+				if (legacyKey) url.searchParams.delete(legacyKey);
+				window.history.replaceState({}, "", url.toString());
+				window.dispatchEvent(new Event(SEARCH_PARAMS_EVENT));
+				return resolved;
+			});
+		};
+		$[13] = legacyKey;
+		$[14] = paramKey;
+		$[15] = sidebarId;
+		$[16] = t5;
+	} else t5 = $[16];
+	const setOpen = t5;
+	let t6;
+	if ($[17] !== open || $[18] !== setOpen) {
+		t6 = [open, setOpen];
+		$[17] = open;
+		$[18] = setOpen;
+		$[19] = t6;
+	} else t6 = $[19];
+	return t6;
+}
+
+//#endregion
+export { useSidebarSearchParam };