@questpie/admin 1.1.1 → 3.0.0

package/dist/client/hooks/use-audit-history.mjs

@@ -0,0 +1,157 @@
+import { selectClient, useAdminStore } from "../runtime/provider.mjs";
+import { c } from "react/compiler-runtime";
+import { useQuery } from "@tanstack/react-query";
+
+//#region src/client/hooks/use-audit-history.ts
+function useAuditFetcher(path) {
+	const $ = c(5);
+	const client = useAdminStore(selectClient);
+	let t0;
+	if ($[0] !== client) {
+		t0 = client.getBasePath?.() ?? "";
+		$[0] = client;
+		$[1] = t0;
+	} else t0 = $[1];
+	const basePath = t0;
+	let t1;
+	if ($[2] !== basePath || $[3] !== path) {
+		t1 = async (signal) => {
+			const response = await fetch(`${basePath}${path}`, {
+				credentials: "include",
+				headers: { Accept: "application/json" },
+				signal
+			});
+			if (!response.ok) throw new Error(`Failed to fetch audit history: ${response.status}`);
+			const data = await response.json();
+			return Array.isArray(data) ? data : data?.docs ?? data ?? [];
+		};
+		$[2] = basePath;
+		$[3] = path;
+		$[4] = t1;
+	} else t1 = $[4];
+	return t1;
+}
+function useCollectionAuditHistory(collection, id, options, queryOptions) {
+	const $ = c(17);
+	let t0;
+	let t1;
+	let t2;
+	if ($[0] !== collection || $[1] !== id || $[2] !== options) {
+		const params = new URLSearchParams();
+		if (options?.limit) params.set("limit", String(options.limit));
+		t0 = collection;
+		t1 = id;
+		t2 = params.toString() ? `?${params}` : "";
+		$[0] = collection;
+		$[1] = id;
+		$[2] = options;
+		$[3] = t0;
+		$[4] = t1;
+		$[5] = t2;
+	} else {
+		t0 = $[3];
+		t1 = $[4];
+		t2 = $[5];
+	}
+	const fetchAudit = useAuditFetcher(`/${t0}/${t1}/audit${t2}`);
+	let t3;
+	if ($[6] !== collection || $[7] !== id || $[8] !== options) {
+		t3 = [
+			"questpie",
+			"audit",
+			"collection",
+			collection,
+			id,
+			options
+		];
+		$[6] = collection;
+		$[7] = id;
+		$[8] = options;
+		$[9] = t3;
+	} else t3 = $[9];
+	let t4;
+	if ($[10] !== fetchAudit) {
+		t4 = (t5$1) => {
+			const { signal } = t5$1;
+			return fetchAudit(signal);
+		};
+		$[10] = fetchAudit;
+		$[11] = t4;
+	} else t4 = $[11];
+	const t5 = !!collection && !!id && (queryOptions?.enabled ?? true);
+	let t6;
+	if ($[12] !== queryOptions || $[13] !== t3 || $[14] !== t4 || $[15] !== t5) {
+		t6 = {
+			queryKey: t3,
+			queryFn: t4,
+			enabled: t5,
+			...queryOptions
+		};
+		$[12] = queryOptions;
+		$[13] = t3;
+		$[14] = t4;
+		$[15] = t5;
+		$[16] = t6;
+	} else t6 = $[16];
+	return useQuery(t6);
+}
+function useGlobalAuditHistory(globalName, options, queryOptions) {
+	const $ = c(14);
+	let t0;
+	let t1;
+	if ($[0] !== globalName || $[1] !== options) {
+		const params = new URLSearchParams();
+		if (options?.limit) params.set("limit", String(options.limit));
+		t0 = globalName;
+		t1 = params.toString() ? `?${params}` : "";
+		$[0] = globalName;
+		$[1] = options;
+		$[2] = t0;
+		$[3] = t1;
+	} else {
+		t0 = $[2];
+		t1 = $[3];
+	}
+	const fetchAudit = useAuditFetcher(`/globals/${t0}/audit${t1}`);
+	let t2;
+	if ($[4] !== globalName || $[5] !== options) {
+		t2 = [
+			"questpie",
+			"audit",
+			"global",
+			globalName,
+			options
+		];
+		$[4] = globalName;
+		$[5] = options;
+		$[6] = t2;
+	} else t2 = $[6];
+	let t3;
+	if ($[7] !== fetchAudit) {
+		t3 = (t4$1) => {
+			const { signal } = t4$1;
+			return fetchAudit(signal);
+		};
+		$[7] = fetchAudit;
+		$[8] = t3;
+	} else t3 = $[8];
+	const t4 = !!globalName && (queryOptions?.enabled ?? true);
+	let t5;
+	if ($[9] !== queryOptions || $[10] !== t2 || $[11] !== t3 || $[12] !== t4) {
+		t5 = {
+			queryKey: t2,
+			queryFn: t3,
+			enabled: t4,
+			...queryOptions
+		};
+		$[9] = queryOptions;
+		$[10] = t2;
+		$[11] = t3;
+		$[12] = t4;
+		$[13] = t5;
+	} else t5 = $[13];
+	return useQuery(t5);
+}
+
+//#endregion
+export { useCollectionAuditHistory, useGlobalAuditHistory };

package/dist/client/hooks/use-auth.d.mts

@@ -0,0 +1,97 @@
+import { QuestpieApp } from "questpie/client";
+import { createAuthClient } from "better-auth/react";
+import { BetterAuthOptions } from "better-auth";
+
+//#region src/client/hooks/use-auth.d.ts
+
+/**
+ * Extract auth options type from app config
+ */
+type ExtractAuthOptions<T extends QuestpieApp> = T["auth"] extends BetterAuthOptions ? T["auth"] : BetterAuthOptions;
+/**
+ * Options for creating admin auth client
+ */
+type AdminAuthClientOptions = {
+  /**
+   * Base URL of the app API
+   * @example 'http://localhost:3000'
+   */
+  baseURL: string;
+  /**
+   * Base path for auth routes
+   * @default '/auth'
+   */
+  basePath?: string;
+  /**
+   * Custom fetch implementation
+   */
+  fetchOptions?: {
+    credentials?: RequestCredentials;
+    headers?: Record<string, string>;
+  };
+};
+/**
+ * Internal client options type that includes $InferAuth
+ */
+type InternalClientOptions<T extends QuestpieApp> = {
+  baseURL: string;
+  fetchOptions?: {
+    credentials?: RequestCredentials;
+    headers?: Record<string, string>;
+  };
+  $InferAuth: ExtractAuthOptions<T>;
+};
+/**
+ * Create a type-safe Better Auth client for the admin UI
+ *
+ * The returned client includes full type inference from your app auth configuration:
+ * - `useSession()` - React hook for session state (typed based on your user/session schema)
+ * - `signIn` methods (email, social providers configured in QUESTPIE)
+ * - `signOut` - Sign out the current user
+ * - `signUp` - Register new users
+ * - Plugin-specific hooks (e.g., `useListAccounts` for admin plugin)
+ *
+ * @example
+ * ```tsx
+ * import { createAdminAuthClient } from '@questpie/admin/hooks'
+ * import type { app } from "./server/app"
+ *
+ * // Create client with type inference from your app
+ * export const authClient = createAdminAuthClient<typeof app>({
+ *   baseURL: 'http://localhost:3000'
+ * })
+ *
+ * // Session data is fully typed based on your app auth config
+ * function App() {
+ *   const { data: session, isPending } = authClient.useSession()
+ *
+ *   if (isPending) return <Loading />
+ *   if (!session) return <LoginPage authClient={authClient} />
+ *
+ *   // session.user has all fields from your user schema
+ *   return <AdminDashboard user={session.user} />
+ * }
+ * ```
+ */
+declare function createAdminAuthClient<T extends QuestpieApp>(options: AdminAuthClientOptions): ReturnType<typeof createAuthClient<InternalClientOptions<T>>>;
+/**
+ * Hook to access the auth client from AdminProvider context.
+ *
+ * @example
+ * ```tsx
+ * import { useAuthClient } from '@questpie/admin/hooks'
+ *
+ * function LoginPage() {
+ *   const authClient = useAuthClient()
+ *
+ *   const handleLogin = async (email: string, password: string) => {
+ *     await authClient.signIn.email({ email, password })
+ *   }
+ *
+ *   return <LoginForm onSubmit={handleLogin} />
+ * }
+ * ```
+ */
+declare function useAuthClient<T = any>(): T;
+//#endregion
+export { createAdminAuthClient, useAuthClient };

package/dist/{use-auth-BoLmWtmU.mjs → client/hooks/use-auth.mjs}

@@ -1,13 +1,13 @@
-import { f as useAdminStore, i as selectAuthClient } from "./content-locales-provider-BXvuIgfg.mjs";
+import { selectAuthClient, useAdminStore } from "../runtime/provider.mjs";
 import { createAuthClient } from "better-auth/react";
 
 //#region src/client/hooks/use-auth.ts
 /**
 * Create a type-safe Better Auth client for the admin UI
 *
-* The returned client includes full type inference from your CMS auth configuration:
+* The returned client includes full type inference from your app auth configuration:
 * - `useSession()` - React hook for session state (typed based on your user/session schema)
-* - `signIn` methods (email, social providers configured in CMS)
+* - `signIn` methods (email, social providers configured in QUESTPIE)
 * - `signOut` - Sign out the current user
 * - `signUp` - Register new users
 * - Plugin-specific hooks (e.g., `useListAccounts` for admin plugin)
@@ -15,14 +15,14 @@ import { createAuthClient } from "better-auth/react";
 * @example
 * ```tsx
 * import { createAdminAuthClient } from '@questpie/admin/hooks'
-* import type { cms } from './server/cms'
+* import type { app } from "./server/app"
 *
-* // Create client with type inference from your CMS
-* export const authClient = createAdminAuthClient<typeof cms>({
+* // Create client with type inference from your app
+* export const authClient = createAdminAuthClient<typeof app>({
 *   baseURL: 'http://localhost:3000'
 * })
 *
-* // Session data is fully typed based on your CMS auth config
+* // Session data is fully typed based on your app auth config
 * function App() {
 *   const { data: session, isPending } = authClient.useSession()
 *
@@ -35,7 +35,7 @@ import { createAuthClient } from "better-auth/react";
 * ```
 */
 function createAdminAuthClient(options) {
-	const basePath = options.basePath ?? "/cms/auth";
+	const basePath = options.basePath ?? "/auth";
 	return createAuthClient({
 		baseURL: `${options.baseURL}${basePath}`,
 		fetchOptions: {
@@ -84,5 +84,4 @@ function useAuthClientSafe() {
 }
 
 //#endregion
-export { useAuthClient as n, useAuthClientSafe as r, createAdminAuthClient as t };
-//# sourceMappingURL=use-auth-BoLmWtmU.mjs.map
+export { createAdminAuthClient, useAuthClient, useAuthClientSafe };

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

@@ -0,0 +1,71 @@
+import { selectAdmin, useAdminStore } from "../runtime/provider.mjs";
+import { buildFieldDefinitionsFromSchema } from "../utils/build-field-definitions-from-schema.mjs";
+import { useCollectionSchema } from "./use-collection-schema.mjs";
+import { c } from "react/compiler-runtime";
+
+//#region src/client/hooks/use-collection-fields.ts
+function useCollectionFields(collection, t0) {
+	const $ = c(16);
+	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 } = useCollectionSchema(collection, options.schemaQueryOptions);
+	let t2;
+	bb0: {
+		let t3$1;
+		if ($[2] !== options.fallbackFields) {
+			t3$1 = options.fallbackFields ?? {};
+			$[2] = options.fallbackFields;
+			$[3] = t3$1;
+		} else t3$1 = $[3];
+		const fallback = t3$1;
+		if (!schema || !admin) {
+			t2 = fallback;
+			break bb0;
+		}
+		let t4;
+		if ($[4] !== admin || $[5] !== options.buildOptions || $[6] !== schema) {
+			t4 = buildFieldDefinitionsFromSchema(schema, admin.getFields(), options.buildOptions);
+			$[4] = admin;
+			$[5] = options.buildOptions;
+			$[6] = schema;
+			$[7] = t4;
+		} else t4 = $[7];
+		const schemaFields = t4;
+		let t5;
+		if ($[8] !== fallback || $[9] !== schemaFields) {
+			t5 = {
+				...schemaFields,
+				...fallback
+			};
+			$[8] = fallback;
+			$[9] = schemaFields;
+			$[10] = t5;
+		} else t5 = $[10];
+		t2 = t5;
+	}
+	const fields = t2;
+	let t3;
+	if ($[11] !== error || $[12] !== fields || $[13] !== isLoading || $[14] !== schema) {
+		t3 = {
+			fields,
+			schema,
+			isLoading,
+			error
+		};
+		$[11] = error;
+		$[12] = fields;
+		$[13] = isLoading;
+		$[14] = schema;
+		$[15] = t3;
+	} else t3 = $[15];
+	return t3;
+}
+
+//#endregion
+export { useCollectionFields };

package/dist/client/hooks/use-collection-meta.mjs

@@ -0,0 +1,153 @@
+import { selectClient, useAdminStore } from "../runtime/provider.mjs";
+import { c } from "react/compiler-runtime";
+import { useQuery, useSuspenseQuery } from "@tanstack/react-query";
+
+//#region src/client/hooks/use-collection-meta.ts
+/**
+* Hook for fetching collection metadata from the backend
+*
+* Used to get introspection info about collections like:
+* - Title field configuration (which field to display first)
+* - Whether timestamps are enabled
+* - Whether soft delete is enabled
+* - Localized fields
+* - Virtual fields
+*/
+/**
+* Hook to fetch collection metadata from the backend
+*
+* Returns introspection info useful for building dynamic UIs:
+* - title.fieldName: The field to use as display title (instead of _title)
+* - title.type: "field" (sortable) or "virtual" (computed)
+* - timestamps: Whether createdAt/updatedAt are enabled
+* - softDelete: Whether soft delete is enabled
+* - localizedFields: Fields that support i18n
+*
+* @example
+* ```tsx
+* const { data: meta } = useCollectionMeta("posts");
+*
+* // Use title.fieldName instead of _title for first column
+* const firstColumn = meta?.title.fieldName || "_title";
+*
+* // Only show timestamps columns if enabled
+* if (meta?.timestamps) {
+*   columns.push("createdAt", "updatedAt");
+* }
+* ```
+*/
+function useCollectionMeta(collection, queryOptions) {
+	const $ = c(10);
+	const client = useAdminStore(selectClient);
+	let t0;
+	if ($[0] !== collection) {
+		t0 = [
+			"questpie",
+			"collections",
+			collection,
+			"meta"
+		];
+		$[0] = collection;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== client || $[3] !== collection) {
+		t1 = async () => client.collections[collection].meta();
+		$[2] = client;
+		$[3] = collection;
+		$[4] = t1;
+	} else t1 = $[4];
+	const t2 = !!collection && (queryOptions?.enabled ?? true);
+	let t3;
+	if ($[5] !== queryOptions || $[6] !== t0 || $[7] !== t1 || $[8] !== t2) {
+		t3 = {
+			queryKey: t0,
+			queryFn: t1,
+			staleTime: 3e5,
+			gcTime: 18e5,
+			...queryOptions,
+			enabled: t2
+		};
+		$[5] = queryOptions;
+		$[6] = t0;
+		$[7] = t1;
+		$[8] = t2;
+		$[9] = t3;
+	} else t3 = $[9];
+	return useQuery(t3);
+}
+/**
+* Query key for collection meta
+* Useful for prefetching or invalidation
+*/
+function getCollectionMetaQueryKey(collection) {
+	return [
+		"questpie",
+		"collections",
+		collection,
+		"meta"
+	];
+}
+/**
+* Query options factory for collection metadata.
+* Can be used with TanStack Query's prefetching in loaders or with useSuspenseQuery.
+*
+* @example
+* ```ts
+* // In TanStack Start loader
+* export const Route = createFileRoute("/admin/collections/:name")({
+*   loader: async ({ context, params }) => {
+*     await context.queryClient.ensureQueryData(
+*       getCollectionMetaQueryOptions(params.name, context.client)
+*     );
+*   },
+* });
+* ```
+*/
+function getCollectionMetaQueryOptions(collection, client) {
+	return {
+		queryKey: getCollectionMetaQueryKey(collection),
+		queryFn: async () => {
+			return client.collections[collection].meta();
+		},
+		staleTime: 300 * 1e3,
+		gcTime: 1800 * 1e3
+	};
+}
+/**
+* Suspense-enabled hook to fetch collection metadata.
+*
+* Uses useSuspenseQuery so the component will suspend until data is loaded.
+* Must be used within a Suspense boundary.
+*
+* @example
+* ```tsx
+* function TableViewInner({ collection }: Props) {
+*   // This will suspend until meta is loaded
+*   const { data: meta } = useSuspenseCollectionMeta(collection);
+*
+*   // meta is guaranteed to be defined here
+*   const titleField = meta.title.fieldName;
+* }
+*
+* // Wrap with Suspense
+* <Suspense fallback={<Loading />}>
+*   <TableViewInner collection="posts" />
+* </Suspense>
+* ```
+*/
+function useSuspenseCollectionMeta(collection) {
+	const $ = c(3);
+	const client = useAdminStore(selectClient);
+	let t0;
+	if ($[0] !== client || $[1] !== collection) {
+		t0 = getCollectionMetaQueryOptions(collection, client);
+		$[0] = client;
+		$[1] = collection;
+		$[2] = t0;
+	} else t0 = $[2];
+	return useSuspenseQuery(t0);
+}
+
+//#endregion
+export { getCollectionMetaQueryOptions, useCollectionMeta, useSuspenseCollectionMeta };

package/dist/client/hooks/use-collection-schema.mjs

@@ -0,0 +1,90 @@
+import { selectClient, useAdminStore } from "../runtime/provider.mjs";
+import { c } from "react/compiler-runtime";
+import { useQuery } from "@tanstack/react-query";
+
+//#region src/client/hooks/use-collection-schema.ts
+/**
+* Hook for fetching collection schema from the backend
+*
+* Returns full introspection data including:
+* - Field schemas with metadata and validation
+* - Relations metadata
+* - Access control information for current user
+* - JSON Schema for client-side validation
+*/
+/**
+* Hook to fetch collection schema from the backend
+*
+* Returns full introspection data useful for building dynamic forms and UIs:
+* - fields: Complete field metadata including type, label, validation, admin config
+* - relations: Relation metadata with type, target collection(s), and keys
+* - access: Evaluated access control for the current user
+* - validation: JSON Schema for client-side validation
+* - options: Collection options (timestamps, softDelete, versioning)
+*
+* @example
+* ```tsx
+* const { data: schema } = useCollectionSchema("posts");
+*
+* // Build fields dynamically from schema
+* for (const [name, field] of Object.entries(schema?.fields ?? {})) {
+*   const FieldComponent = getFieldComponent(field.metadata.type);
+*   // Use field.metadata for rendering configuration
+* }
+*
+* // Check user access
+* if (schema?.access.operations.create.allowed) {
+*   // Show create button
+* }
+* ```
+*/
+function useCollectionSchema(collection, queryOptions) {
+	const $ = c(10);
+	const client = useAdminStore(selectClient);
+	let t0;
+	if ($[0] !== collection) {
+		t0 = getCollectionSchemaQueryKey(collection);
+		$[0] = collection;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== client || $[3] !== collection) {
+		t1 = async () => client.collections[collection].schema();
+		$[2] = client;
+		$[3] = collection;
+		$[4] = t1;
+	} else t1 = $[4];
+	const t2 = !!collection && (queryOptions?.enabled ?? true);
+	let t3;
+	if ($[5] !== queryOptions || $[6] !== t0 || $[7] !== t1 || $[8] !== t2) {
+		t3 = {
+			queryKey: t0,
+			queryFn: t1,
+			staleTime: 3e5,
+			gcTime: 18e5,
+			...queryOptions,
+			enabled: t2
+		};
+		$[5] = queryOptions;
+		$[6] = t0;
+		$[7] = t1;
+		$[8] = t2;
+		$[9] = t3;
+	} else t3 = $[9];
+	return useQuery(t3);
+}
+/**
+* Query key for collection schema
+* Useful for prefetching or invalidation
+*/
+function getCollectionSchemaQueryKey(collection) {
+	return [
+		"questpie",
+		"collections",
+		collection,
+		"schema"
+	];
+}
+
+//#endregion
+export { useCollectionSchema };

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

@@ -0,0 +1,88 @@
+import { createFormSchema } from "../builder/validation.mjs";
+import { useCollectionFields } from "./use-collection-fields.mjs";
+import { useValidationErrorMap } from "./use-validation-error-map.mjs";
+import { c } from "react/compiler-runtime";
+
+//#region src/client/hooks/use-collection-validation.ts
+/**
+* Get a ready-to-use resolver for react-hook-form
+*
+* This is the recommended hook - provides full automatic validation
+* with i18n error messages. Just pass the result to useForm's resolver.
+*
+* @param collection - Collection name
+* @returns Resolver function for react-hook-form, or undefined if collection not found
+*
+* @example
+* ```tsx
+* function MyForm() {
+*   const resolver = useCollectionValidation("posts");
+*
+*   const form = useForm({
+*     resolver,
+*   });
+*
+*   // That's it! Validation and i18n errors work automatically.
+* }
+* ```
+*/
+function useCollectionValidation(collection) {
+	const $ = c(5);
+	const { fields } = useCollectionFields(collection);
+	let t0;
+	bb0: {
+		if (!fields || Object.keys(fields).length === 0) {
+			t0 = void 0;
+			break bb0;
+		}
+		let t1$1;
+		if ($[0] !== fields) {
+			t1$1 = createFormSchema(fields);
+			$[0] = fields;
+			$[1] = t1$1;
+		} else t1$1 = $[1];
+		t0 = t1$1;
+	}
+	const schema = t0;
+	const errorMap = useValidationErrorMap();
+	let t1;
+	if ($[2] !== errorMap || $[3] !== schema) {
+		t1 = async (values, _context, _options) => {
+			if (!schema) return {
+				values,
+				errors: {}
+			};
+			const result = schema.safeParse(values);
+			if (result.success) return {
+				values: result.data,
+				errors: {}
+			};
+			return {
+				values: {},
+				errors: zodErrorToFieldErrors(result.error, errorMap)
+			};
+		};
+		$[2] = errorMap;
+		$[3] = schema;
+		$[4] = t1;
+	} else t1 = $[4];
+	return schema ? t1 : void 0;
+}
+/**
+* Convert Zod error to react-hook-form FieldErrors format with i18n support
+*/
+function zodErrorToFieldErrors(error, errorMap) {
+	const errors = {};
+	for (const issue of error.issues) {
+		const path = issue.path.join(".");
+		const { message } = errorMap(issue);
+		if (path && !errors[path]) errors[path] = {
+			type: issue.code,
+			message
+		};
+	}
+	return errors;
+}
+
+//#endregion
+export { useCollectionValidation };