@questpie/admin 1.1.1 → 3.0.0

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

@@ -0,0 +1,329 @@
+"use client";
+
+import { useTranslation } from "../i18n/hooks.mjs";
+import { selectBasePath, selectClient, selectContentLocale, selectNavigate, useAdminStore } from "../runtime/provider.mjs";
+import { getDefaultActionsConfig } from "../builder/types/action-registry.mjs";
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
+import { createQuestpieQueryOptions } from "@questpie/tanstack-query";
+
+//#region src/client/hooks/use-action.ts
+/**
+* useAction Hook
+*
+* Provides action helpers and state management for collection actions.
+* Handles action execution, navigation, and API calls.
+*/
+/** Query key prefix for app queries (must match use-collection.ts) */
+const QUERY_KEY_PREFIX = ["questpie", "collections"];
+/**
+* Hook to create action helpers for a collection
+*
+* @example
+* ```tsx
+* const { helpers } = useActionHelpers({ collection: "posts" });
+*
+* return (
+*   <HeaderActions
+*     actions={headerActions}
+*     collection="posts"
+*     helpers={helpers}
+*   />
+* );
+* ```
+*/
+function useActionHelpers(t0) {
+	const $ = c(34);
+	const { collection, onRefresh } = t0;
+	const basePath = useAdminStore(selectBasePath);
+	const navigate = useAdminStore(selectNavigate);
+	const client = useAdminStore(selectClient);
+	const contentLocale = useAdminStore(selectContentLocale);
+	const queryClient = useQueryClient();
+	const { t } = useTranslation();
+	const t1 = client;
+	let t2;
+	if ($[0] !== contentLocale || $[1] !== t1) {
+		t2 = createQuestpieQueryOptions(t1, {
+			keyPrefix: QUERY_KEY_PREFIX,
+			locale: contentLocale
+		});
+		$[0] = contentLocale;
+		$[1] = t1;
+		$[2] = t2;
+	} else t2 = $[2];
+	const queryOpts = t2;
+	let t3;
+	if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+		t3 = {
+			success: toast.success,
+			error: toast.error,
+			info: toast.info,
+			warning: toast.warning
+		};
+		$[3] = t3;
+	} else t3 = $[3];
+	let t4;
+	if ($[4] !== collection || $[5] !== contentLocale || $[6] !== onRefresh || $[7] !== queryClient || $[8] !== queryOpts) {
+		t4 = async (targetCollection) => {
+			const col = targetCollection || collection;
+			await queryClient.invalidateQueries({ queryKey: queryOpts.key([
+				"collections",
+				col,
+				"find",
+				contentLocale
+			]) });
+			await queryClient.invalidateQueries({ queryKey: queryOpts.key([
+				"collections",
+				col,
+				"count",
+				contentLocale
+			]) });
+			onRefresh?.();
+		};
+		$[4] = collection;
+		$[5] = contentLocale;
+		$[6] = onRefresh;
+		$[7] = queryClient;
+		$[8] = queryOpts;
+		$[9] = t4;
+	} else t4 = $[9];
+	let t5;
+	if ($[10] !== collection || $[11] !== contentLocale || $[12] !== queryClient || $[13] !== queryOpts) {
+		t5 = async (itemId, targetCollection_0) => {
+			const col_0 = targetCollection_0 || collection;
+			await queryClient.invalidateQueries({ queryKey: queryOpts.key([
+				"collections",
+				col_0,
+				"findOne",
+				contentLocale,
+				{ id: itemId }
+			]) });
+			await queryClient.invalidateQueries({ queryKey: queryOpts.key([
+				"collections",
+				col_0,
+				"find",
+				contentLocale
+			]) });
+		};
+		$[10] = collection;
+		$[11] = contentLocale;
+		$[12] = queryClient;
+		$[13] = queryOpts;
+		$[14] = t5;
+	} else t5 = $[14];
+	let t6;
+	if ($[15] !== onRefresh || $[16] !== queryClient) {
+		t6 = async () => {
+			await queryClient.invalidateQueries({ queryKey: [...QUERY_KEY_PREFIX] });
+			onRefresh?.();
+		};
+		$[15] = onRefresh;
+		$[16] = queryClient;
+		$[17] = t6;
+	} else t6 = $[17];
+	let t7;
+	if ($[18] !== collection || $[19] !== contentLocale || $[20] !== onRefresh || $[21] !== queryClient || $[22] !== queryOpts) {
+		t7 = () => {
+			queryClient.invalidateQueries({ queryKey: queryOpts.key([
+				"collections",
+				collection,
+				"find",
+				contentLocale
+			]) });
+			queryClient.invalidateQueries({ queryKey: queryOpts.key([
+				"collections",
+				collection,
+				"count",
+				contentLocale
+			]) });
+			onRefresh?.();
+		};
+		$[18] = collection;
+		$[19] = contentLocale;
+		$[20] = onRefresh;
+		$[21] = queryClient;
+		$[22] = queryOpts;
+		$[23] = t7;
+	} else t7 = $[23];
+	let t8;
+	if ($[24] !== basePath || $[25] !== navigate || $[26] !== t || $[27] !== t4 || $[28] !== t5 || $[29] !== t6 || $[30] !== t7) {
+		t8 = {
+			navigate,
+			toast: t3,
+			t,
+			invalidateCollection: t4,
+			invalidateItem: t5,
+			invalidateAll: t6,
+			refresh: t7,
+			closeDialog: _temp,
+			basePath
+		};
+		$[24] = basePath;
+		$[25] = navigate;
+		$[26] = t;
+		$[27] = t4;
+		$[28] = t5;
+		$[29] = t6;
+		$[30] = t7;
+		$[31] = t8;
+	} else t8 = $[31];
+	const helpers = t8;
+	let t9;
+	if ($[32] !== helpers) {
+		t9 = { helpers };
+		$[32] = helpers;
+		$[33] = t9;
+	} else t9 = $[33];
+	return t9;
+}
+/**
+* Hook to manage collection actions with dialog state
+*
+* @example
+* ```tsx
+* const {
+*   helpers,
+*   actions,
+*   dialogAction,
+*   dialogItem,
+*   openDialog,
+*   closeDialog,
+* } = useActions({
+*   collection: "posts",
+*   actionsConfig: config.actions,
+* });
+*
+* return (
+*   <>
+*     <HeaderActions
+*       actions={actions.header}
+*       collection="posts"
+*       helpers={helpers}
+*       onOpenDialog={openDialog}
+*     />
+*
+*     {dialogAction && (
+*       <ActionDialog
+*         open={!!dialogAction}
+*         onOpenChange={(open) => !open && closeDialog()}
+*         action={dialogAction}
+*         collection="posts"
+*         item={dialogItem}
+*         helpers={helpers}
+*       />
+*     )}
+*   </>
+* );
+* ```
+*/
+function _temp() {}
+function useActions(t0) {
+	const $ = c(22);
+	const { collection, actionsConfig, onRefresh } = t0;
+	const [dialogAction, setDialogAction] = React.useState(null);
+	const [dialogItem, setDialogItem] = React.useState(null);
+	let t1;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = getDefaultActionsConfig();
+		$[0] = t1;
+	} else t1 = $[0];
+	const defaultActions = t1;
+	let t2;
+	if ($[1] !== actionsConfig) {
+		t2 = actionsConfig?.header && (actionsConfig.header.primary?.length > 0 || actionsConfig.header.secondary?.length > 0) ? actionsConfig.header : defaultActions.header ?? {
+			primary: [],
+			secondary: []
+		};
+		$[1] = actionsConfig;
+		$[2] = t2;
+	} else t2 = $[2];
+	let t3;
+	if ($[3] !== actionsConfig) {
+		t3 = actionsConfig?.bulk && actionsConfig.bulk.length > 0 ? actionsConfig.bulk : defaultActions.bulk ?? [];
+		$[3] = actionsConfig;
+		$[4] = t3;
+	} else t3 = $[4];
+	let t4;
+	if ($[5] !== t2 || $[6] !== t3) {
+		t4 = {
+			header: t2,
+			bulk: t3
+		};
+		$[5] = t2;
+		$[6] = t3;
+		$[7] = t4;
+	} else t4 = $[7];
+	const actions = t4;
+	let t5;
+	if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+		t5 = () => {
+			setDialogAction(null);
+			setDialogItem(null);
+		};
+		$[8] = t5;
+	} else t5 = $[8];
+	const closeDialog = t5;
+	let t6;
+	if ($[9] !== onRefresh) {
+		t6 = () => {
+			onRefresh?.();
+		};
+		$[9] = onRefresh;
+		$[10] = t6;
+	} else t6 = $[10];
+	let t7;
+	if ($[11] !== collection || $[12] !== t6) {
+		t7 = {
+			collection,
+			onRefresh: t6
+		};
+		$[11] = collection;
+		$[12] = t6;
+		$[13] = t7;
+	} else t7 = $[13];
+	const { helpers: baseHelpers } = useActionHelpers(t7);
+	let t8;
+	if ($[14] !== baseHelpers) {
+		t8 = {
+			...baseHelpers,
+			closeDialog
+		};
+		$[14] = baseHelpers;
+		$[15] = t8;
+	} else t8 = $[15];
+	const helpers = t8;
+	let t9;
+	if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+		t9 = (action, item) => {
+			setDialogAction(action);
+			setDialogItem(item ?? null);
+		};
+		$[16] = t9;
+	} else t9 = $[16];
+	const openDialog = t9;
+	let t10;
+	if ($[17] !== actions || $[18] !== dialogAction || $[19] !== dialogItem || $[20] !== helpers) {
+		t10 = {
+			helpers,
+			actions,
+			dialogAction,
+			setDialogAction,
+			dialogItem,
+			setDialogItem,
+			openDialog,
+			closeDialog
+		};
+		$[17] = actions;
+		$[18] = dialogAction;
+		$[19] = dialogItem;
+		$[20] = helpers;
+		$[21] = t10;
+	} else t10 = $[21];
+	return t10;
+}
+
+//#endregion
+export { useActions };

package/dist/client/hooks/use-admin-config.mjs

@@ -0,0 +1,69 @@
+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-admin-config.ts
+/**
+* Hook for fetching server-side admin config
+*/
+/** Query key for admin config */
+const adminConfigQueryKey = [
+	"questpie",
+	"admin",
+	"config"
+];
+/** Query options factory for admin config — can be used for prefetching in loaders */
+function getAdminConfigQueryOptions(client) {
+	return {
+		queryKey: adminConfigQueryKey,
+		queryFn: async () => {
+			if (!client || !client.routes) return {};
+			return client.routes.getAdminConfig();
+		},
+		staleTime: 300 * 1e3,
+		gcTime: 1800 * 1e3
+	};
+}
+/** Standard query hook - returns loading/error states */
+function useAdminConfig(queryOptions) {
+	const $ = c(5);
+	const client = useAdminStore(selectClient);
+	let t0;
+	if ($[0] !== client) {
+		t0 = getAdminConfigQueryOptions(client);
+		$[0] = client;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== queryOptions || $[3] !== t0) {
+		t1 = {
+			...t0,
+			...queryOptions
+		};
+		$[2] = queryOptions;
+		$[3] = t0;
+		$[4] = t1;
+	} else t1 = $[4];
+	return useQuery(t1);
+}
+/** Suspense query hook - suspends until data is ready, no loading checks needed */
+function useSuspenseAdminConfig() {
+	const $ = c(4);
+	const client = useAdminStore(selectClient);
+	let t0;
+	if ($[0] !== client) {
+		t0 = getAdminConfigQueryOptions(client);
+		$[0] = client;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== t0) {
+		t1 = { ...t0 };
+		$[2] = t0;
+		$[3] = t1;
+	} else t1 = $[3];
+	return useSuspenseQuery(t1);
+}
+
+//#endregion
+export { getAdminConfigQueryOptions, useAdminConfig, useSuspenseAdminConfig };

package/dist/client/hooks/use-admin-preferences.mjs

@@ -0,0 +1,171 @@
+import { useAdminStore } from "../runtime/provider.mjs";
+import { useCurrentUser } from "./use-current-user.mjs";
+import { c } from "react/compiler-runtime";
+import { useMutation, useQuery, useQueryClient, useSuspenseQuery } from "@tanstack/react-query";
+
+//#region src/client/hooks/use-admin-preferences.ts
+/**
+* Get query key for admin preference
+*/
+function getAdminPreferenceQueryKey(userId, key) {
+	return [
+		"admin_preferences",
+		userId,
+		key
+	];
+}
+/**
+* Hook to fetch a single admin preference by key
+*
+* @param key - Preference key (e.g., "viewState:posts")
+* @returns Query result with preference data or null if not found
+*
+* @example
+* ```tsx
+* const { data, isLoading } = useAdminPreference<ViewConfiguration>("viewState:posts");
+* if (isLoading) return <Loading />;
+* const viewConfig = data ?? defaultConfig;
+* ```
+*/
+function useAdminPreference(key) {
+	const $ = c(11);
+	const client = useAdminStore(_temp);
+	const user = useCurrentUser();
+	const t0 = user?.id;
+	let t1;
+	if ($[0] !== key || $[1] !== t0) {
+		t1 = [
+			"admin_preferences",
+			t0,
+			key
+		];
+		$[0] = key;
+		$[1] = t0;
+		$[2] = t1;
+	} else t1 = $[2];
+	let t2;
+	if ($[3] !== client || $[4] !== key || $[5] !== user) {
+		t2 = async () => {
+			if (!user?.id) return null;
+			return (await client.collections.admin_preferences.findOne({ where: {
+				userId: user.id,
+				key
+			} }))?.value ?? null;
+		};
+		$[3] = client;
+		$[4] = key;
+		$[5] = user;
+		$[6] = t2;
+	} else t2 = $[6];
+	const t3 = !!client && !!user?.id;
+	let t4;
+	if ($[7] !== t1 || $[8] !== t2 || $[9] !== t3) {
+		t4 = {
+			queryKey: t1,
+			queryFn: t2,
+			enabled: t3
+		};
+		$[7] = t1;
+		$[8] = t2;
+		$[9] = t3;
+		$[10] = t4;
+	} else t4 = $[10];
+	return useQuery(t4);
+}
+/**
+* Hook to set an admin preference
+*
+* Creates or updates the preference for the current user.
+*
+* @param key - Preference key (e.g., "viewState:posts")
+* @returns Mutation for setting the preference
+*
+* @example
+* ```tsx
+* const { mutate: setPreference, isPending } = useSetAdminPreference<ViewConfiguration>("viewState:posts");
+*
+* const handleSave = () => {
+*   setPreference(viewConfig);
+* };
+* ```
+*/
+function _temp(s) {
+	return s.client;
+}
+function useSetAdminPreference(key) {
+	const $ = c(11);
+	const client = useAdminStore(_temp2);
+	const user = useCurrentUser();
+	const queryClient = useQueryClient();
+	let t0;
+	if ($[0] !== client?.collections || $[1] !== key || $[2] !== user) {
+		t0 = async (value) => {
+			if (!user?.id) throw new Error("User must be logged in to save preferences");
+			const collections = client?.collections;
+			if (!collections?.admin_preferences) throw new Error("admin_preferences collection not available. Make sure to use the adminModule in your app setup.");
+			const existing = await collections.admin_preferences.findOne({ where: {
+				userId: user.id,
+				key
+			} });
+			if (existing) return collections.admin_preferences.update({
+				id: existing.id,
+				data: { value }
+			});
+			return collections.admin_preferences.create({
+				userId: user.id,
+				key,
+				value
+			});
+		};
+		$[0] = client?.collections;
+		$[1] = key;
+		$[2] = user;
+		$[3] = t0;
+	} else t0 = $[3];
+	let t1;
+	if ($[4] !== key || $[5] !== queryClient || $[6] !== user?.id) {
+		t1 = () => {
+			queryClient.invalidateQueries({ queryKey: [
+				"admin_preferences",
+				user?.id,
+				key
+			] });
+		};
+		$[4] = key;
+		$[5] = queryClient;
+		$[6] = user?.id;
+		$[7] = t1;
+	} else t1 = $[7];
+	let t2;
+	if ($[8] !== t0 || $[9] !== t1) {
+		t2 = {
+			mutationFn: t0,
+			onSuccess: t1
+		};
+		$[8] = t0;
+		$[9] = t1;
+		$[10] = t2;
+	} else t2 = $[10];
+	return useMutation(t2);
+}
+/**
+* Hook to delete an admin preference
+*
+* @param key - Preference key (e.g., "viewState:posts")
+* @returns Mutation for deleting the preference
+*
+* @example
+* ```tsx
+* const { mutate: deletePreference } = useDeleteAdminPreference("viewState:posts");
+*
+* const handleReset = () => {
+*   deletePreference();
+* };
+* ```
+*/
+function _temp2(s) {
+	return s.client;
+}
+
+//#endregion
+export { getAdminPreferenceQueryKey, useAdminPreference, useSetAdminPreference };

package/dist/client/hooks/use-admin-routes.mjs

@@ -0,0 +1,130 @@
+import { selectAdmin, selectBasePath, selectNavigate, useAdminStore } from "../runtime/provider.mjs";
+import { createAdminRoutes, createNavigator } from "../utils/routes.mjs";
+import { c } from "react/compiler-runtime";
+
+//#region src/client/hooks/use-admin-routes.ts
+/**
+* Hook for type-safe admin route navigation
+*
+* @example
+* ```tsx
+* function MyComponent() {
+*   const { toDashboard, toCollection, toCollectionEdit } = useAdminRoutes<App>()
+*
+*   return (
+*     <div>
+*       <button onClick={toDashboard}>Dashboard</button>
+*       <button onClick={() => toCollection('posts')}>View Posts</button>
+*       <button onClick={() => toCollectionEdit('posts', '123')}>Edit Post</button>
+*     </div>
+*   )
+* }
+* ```
+*
+* @example
+* ```tsx
+* // Get URLs without navigating
+* function LinkList() {
+*   const { collectionUrl, globalUrl, pageUrl } = useAdminRoutes<App>()
+*
+*   return (
+*     <nav>
+*       <a href={collectionUrl('posts')}>Posts</a>
+*       <a href={collectionUrl('users')}>Users</a>
+*       <a href={globalUrl('siteSettings')}>Settings</a>
+*       <a href={pageUrl('analytics') ?? '#'}>Analytics</a>
+*     </nav>
+*   )
+* }
+* ```
+*/
+function useAdminRoutes(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 storeBasePath = useAdminStore(selectBasePath);
+	const storeNavigate = useAdminStore(selectNavigate);
+	const basePath = options.basePath ?? storeBasePath;
+	let t2;
+	if ($[2] !== admin || $[3] !== basePath) {
+		t2 = createAdminRoutes(admin, { basePath });
+		$[2] = admin;
+		$[3] = basePath;
+		$[4] = t2;
+	} else t2 = $[4];
+	const routes = t2;
+	const navigate = storeNavigate;
+	let t3;
+	if ($[5] !== navigate || $[6] !== routes) {
+		t3 = createNavigator(routes, navigate);
+		$[5] = navigate;
+		$[6] = routes;
+		$[7] = t3;
+	} else t3 = $[7];
+	const nav = t3;
+	let t4;
+	if ($[8] !== nav.collection || $[9] !== nav.collectionCreate || $[10] !== nav.collectionEdit || $[11] !== nav.dashboard || $[12] !== nav.global || $[13] !== nav.page || $[14] !== routes) {
+		t4 = {
+			routes,
+			toDashboard: nav.dashboard,
+			toCollection: nav.collection,
+			toCollectionCreate: nav.collectionCreate,
+			toCollectionEdit: nav.collectionEdit,
+			toGlobal: nav.global,
+			toPage: nav.page,
+			dashboardUrl: routes.dashboard,
+			collectionUrl: routes.collections.list,
+			collectionCreateUrl: routes.collections.create,
+			collectionEditUrl: routes.collections.edit,
+			globalUrl: routes.globals.edit,
+			pageUrl: routes.pages.byId,
+			allPageUrls: routes.pages.all,
+			parse: routes.parse,
+			matches: routes.matches
+		};
+		$[8] = nav.collection;
+		$[9] = nav.collectionCreate;
+		$[10] = nav.collectionEdit;
+		$[11] = nav.dashboard;
+		$[12] = nav.global;
+		$[13] = nav.page;
+		$[14] = routes;
+		$[15] = t4;
+	} else t4 = $[15];
+	return t4;
+}
+/**
+* Get href for admin link props
+*
+* @example
+* ```tsx
+* function AdminLink<TApp extends QuestpieApp>(
+*   props: AdminLinkProps<TApp> & { children: React.ReactNode }
+* ) {
+*   const { routes } = useAdminRoutes<TApp>()
+*   const href = getAdminLinkHref(routes, props)
+*   return <a href={href}>{props.children}</a>
+* }
+* ```
+*/
+function getAdminLinkHref(routes, props) {
+	if (props.to === "dashboard") return routes.dashboard();
+	if (props.collection) {
+		const action = props.action ?? "list";
+		if (action === "create") return routes.collections.create(props.collection);
+		if (action === "edit" && props.id) return routes.collections.edit(props.collection, props.id);
+		return routes.collections.list(props.collection);
+	}
+	if (props.global) return routes.globals.edit(props.global);
+	if (props.pageId) return routes.pages.byId(props.pageId) ?? routes.dashboard();
+	return routes.dashboard();
+}
+
+//#endregion
+export { getAdminLinkHref, useAdminRoutes };