@questpie/admin 1.1.1 → 3.0.0

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

@@ -0,0 +1,452 @@
+import { useQuestpieQueryOptions } from "./use-questpie-query-options.mjs";
+import { useCurrentUser } from "./use-current-user.mjs";
+import { c } from "react/compiler-runtime";
+import { useEffect, useRef } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/client/hooks/use-locks.ts
+/**
+* Hooks for document locking (collaborative editing awareness)
+*
+* Provides realtime tracking of who is editing which documents.
+* Used in table view to show lock indicators and in form view to manage locks.
+*/
+/**
+* Default lock duration in milliseconds (60 seconds)
+* Lock expires if not refreshed within this time.
+* Form should call refresh() on user activity (typing, clicking).
+*/
+const LOCK_DURATION_MS = 6e4;
+/** Helper to get user info from lock (handles both expanded and non-expanded) */
+function getLockUser(lock) {
+	if (typeof lock.user === "string") return null;
+	return lock.user;
+}
+/** Helper to get user ID from lock */
+function getLockUserId(lock) {
+	if (typeof lock.user === "string") return lock.user;
+	return lock.user.id;
+}
+/**
+* Generate a unique session ID for this browser tab.
+* Persisted in sessionStorage so it survives page refreshes but not tab close.
+*/
+function getSessionId() {
+	if (typeof window === "undefined") return "server";
+	const key = "__questpie_lock_session_id__";
+	let sessionId = sessionStorage.getItem(key);
+	if (!sessionId) {
+		sessionId = crypto.randomUUID();
+		sessionStorage.setItem(key, sessionId);
+	}
+	return sessionId;
+}
+/**
+* Track all active locks for a collection/global.
+*
+* Used in table views to show who is editing which rows.
+*
+* @example
+* ```tsx
+* const { locks, isLocked, getLock } = useLocks({
+*   resourceType: "collection",
+*   resource: "posts",
+*   realtime: true,
+* });
+*
+* // In table row
+* {isLocked(row.id) && (
+*   <LockIndicator user={getLock(row.id)?.userName} />
+* )}
+* ```
+*/
+function useLocks(options) {
+	const $ = c(22);
+	const { resourceType, resource, realtime: t0 } = options;
+	const realtime = t0 === void 0 ? true : t0;
+	const { queryOpts } = useQuestpieQueryOptions();
+	const currentUser = useCurrentUser();
+	const t1 = queryOpts;
+	let t2;
+	if ($[0] !== realtime || $[1] !== resource || $[2] !== resourceType || $[3] !== t1.collections.admin_locks) {
+		t2 = t1.collections.admin_locks.find({
+			where: {
+				resourceType,
+				resource,
+				expiresAt: { gt: /* @__PURE__ */ new Date() }
+			},
+			with: { user: true }
+		}, { realtime });
+		$[0] = realtime;
+		$[1] = resource;
+		$[2] = resourceType;
+		$[3] = t1.collections.admin_locks;
+		$[4] = t2;
+	} else t2 = $[4];
+	let t3;
+	if ($[5] !== t2) {
+		t3 = { ...t2 };
+		$[5] = t2;
+		$[6] = t3;
+	} else t3 = $[6];
+	const { data: rawData, isLoading } = useQuery(t3);
+	const data = rawData;
+	let locks;
+	if ($[7] !== data) {
+		locks = /* @__PURE__ */ new Map();
+		if (data?.docs) for (const lock of data.docs) locks.set(lock.resourceId, lock);
+		$[7] = data;
+		$[8] = locks;
+	} else locks = $[8];
+	let t4;
+	if ($[9] !== locks) {
+		t4 = (resourceId) => locks.has(resourceId);
+		$[9] = locks;
+		$[10] = t4;
+	} else t4 = $[10];
+	const isLocked = t4;
+	let t5;
+	if ($[11] !== locks) {
+		t5 = (resourceId_0) => locks.get(resourceId_0);
+		$[11] = locks;
+		$[12] = t5;
+	} else t5 = $[12];
+	const getLock = t5;
+	let t6;
+	if ($[13] !== currentUser?.id || $[14] !== locks) {
+		t6 = (resourceId_1) => {
+			const lock_0 = locks.get(resourceId_1);
+			if (!lock_0) return false;
+			return getLockUserId(lock_0) === currentUser?.id;
+		};
+		$[13] = currentUser?.id;
+		$[14] = locks;
+		$[15] = t6;
+	} else t6 = $[15];
+	currentUser?.id;
+	const isOwnLock = t6;
+	let t7;
+	if ($[16] !== getLock || $[17] !== isLoading || $[18] !== isLocked || $[19] !== isOwnLock || $[20] !== locks) {
+		t7 = {
+			locks,
+			isLocked,
+			getLock,
+			isOwnLock,
+			isLoading
+		};
+		$[16] = getLock;
+		$[17] = isLoading;
+		$[18] = isLocked;
+		$[19] = isOwnLock;
+		$[20] = locks;
+		$[21] = t7;
+	} else t7 = $[21];
+	return t7;
+}
+/**
+* Manage a document lock for editing.
+*
+* Automatically acquires lock on mount, sends heartbeats, and releases on unmount.
+*
+* @example
+* ```tsx
+* function EditForm({ collection, id }) {
+*   const { isLocked, isBlocked, blockedBy } = useLock({
+*     resourceType: "collection",
+*     resource: collection,
+*     resourceId: id,
+*   });
+*
+*   if (isBlocked) {
+*     return <LockedBanner user={blockedBy?.userName} />;
+*   }
+*
+*   return <Form disabled={!isLocked} />;
+* }
+* ```
+*/
+function useLock(options) {
+	const $ = c(67);
+	const { resourceType, resource, resourceId, autoAcquire: t0, onAcquired, onBlocked, onReleased } = options;
+	const autoAcquire = t0 === void 0 ? true : t0;
+	const { queryOpts } = useQuestpieQueryOptions();
+	const queryClient = useQueryClient();
+	const currentUser = useCurrentUser();
+	const lockIdRef = useRef(null);
+	const t1 = queryOpts;
+	let t2;
+	if ($[0] !== resource || $[1] !== resourceId || $[2] !== resourceType || $[3] !== t1.collections.admin_locks) {
+		t2 = t1.collections.admin_locks.find({
+			where: {
+				resourceType,
+				resource,
+				resourceId,
+				expiresAt: { gt: /* @__PURE__ */ new Date() }
+			},
+			with: { user: true },
+			limit: 1
+		});
+		$[0] = resource;
+		$[1] = resourceId;
+		$[2] = resourceType;
+		$[3] = t1.collections.admin_locks;
+		$[4] = t2;
+	} else t2 = $[4];
+	const t3 = !!resourceId;
+	let t4;
+	if ($[5] !== t2 || $[6] !== t3) {
+		t4 = {
+			...t2,
+			enabled: t3
+		};
+		$[5] = t2;
+		$[6] = t3;
+		$[7] = t4;
+	} else t4 = $[7];
+	const { data: rawExistingLockData, isLoading: isCheckingLock } = useQuery(t4);
+	const existingLock = rawExistingLockData?.docs?.[0] ?? null;
+	let t5;
+	if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+		t5 = getSessionId();
+		$[8] = t5;
+	} else t5 = $[8];
+	const sessionId = t5;
+	const isOwnSession = existingLock?.sessionId === sessionId;
+	let t6;
+	if ($[9] !== currentUser?.id || $[10] !== existingLock) {
+		t6 = existingLock ? getLockUserId(existingLock) === currentUser?.id : false;
+		$[9] = currentUser?.id;
+		$[10] = existingLock;
+		$[11] = t6;
+	} else t6 = $[11];
+	const isOwnUser = t6;
+	const blockedBy = existingLock && !isOwnUser ? existingLock : null;
+	const ownLockElsewhere = existingLock && isOwnUser && !isOwnSession;
+	let t7;
+	if ($[12] !== currentUser || $[13] !== queryOpts || $[14] !== resource || $[15] !== resourceId || $[16] !== resourceType) {
+		t7 = async () => {
+			if (!currentUser) throw new Error("Not authenticated");
+			const expiresAt = new Date(Date.now() + LOCK_DURATION_MS);
+			return await queryOpts.collections.admin_locks.create({
+				resourceType,
+				resource,
+				resourceId,
+				user: currentUser.id,
+				sessionId,
+				expiresAt
+			});
+		};
+		$[12] = currentUser;
+		$[13] = queryOpts;
+		$[14] = resource;
+		$[15] = resourceId;
+		$[16] = resourceType;
+		$[17] = t7;
+	} else t7 = $[17];
+	let t8;
+	if ($[18] !== onAcquired || $[19] !== queryClient) {
+		t8 = (lock) => {
+			lockIdRef.current = lock.id;
+			onAcquired?.(lock);
+			queryClient.invalidateQueries({ queryKey: ["collections", "admin_locks"] });
+		};
+		$[18] = onAcquired;
+		$[19] = queryClient;
+		$[20] = t8;
+	} else t8 = $[20];
+	let t9;
+	if ($[21] !== t7 || $[22] !== t8) {
+		t9 = {
+			mutationFn: t7,
+			onSuccess: t8
+		};
+		$[21] = t7;
+		$[22] = t8;
+		$[23] = t9;
+	} else t9 = $[23];
+	const createMutation = useMutation(t9);
+	let t10;
+	if ($[24] !== queryOpts) {
+		t10 = { mutationFn: async () => {
+			if (!lockIdRef.current) return;
+			const expiresAt_0 = new Date(Date.now() + LOCK_DURATION_MS);
+			await queryOpts.collections.admin_locks.update({
+				id: lockIdRef.current,
+				data: { expiresAt: expiresAt_0 }
+			});
+		} };
+		$[24] = queryOpts;
+		$[25] = t10;
+	} else t10 = $[25];
+	const updateMutation = useMutation(t10);
+	let t11;
+	if ($[26] !== queryOpts) {
+		t11 = async () => {
+			if (!lockIdRef.current) return;
+			await queryOpts.collections.admin_locks.delete({ id: lockIdRef.current });
+		};
+		$[26] = queryOpts;
+		$[27] = t11;
+	} else t11 = $[27];
+	let t12;
+	if ($[28] !== onReleased || $[29] !== queryClient) {
+		t12 = () => {
+			lockIdRef.current = null;
+			onReleased?.();
+			queryClient.invalidateQueries({ queryKey: ["collections", "admin_locks"] });
+		};
+		$[28] = onReleased;
+		$[29] = queryClient;
+		$[30] = t12;
+	} else t12 = $[30];
+	let t13;
+	if ($[31] !== t11 || $[32] !== t12) {
+		t13 = {
+			mutationFn: t11,
+			onSuccess: t12
+		};
+		$[31] = t11;
+		$[32] = t12;
+		$[33] = t13;
+	} else t13 = $[33];
+	const deleteMutation = useMutation(t13);
+	let t14;
+	if ($[34] !== createMutation || $[35] !== existingLock || $[36] !== isOwnSession || $[37] !== isOwnUser || $[38] !== onBlocked) {
+		t14 = async () => {
+			if (existingLock && !isOwnUser) {
+				onBlocked?.(existingLock);
+				return null;
+			}
+			if (isOwnSession && existingLock) {
+				lockIdRef.current = existingLock.id;
+				return existingLock;
+			}
+			try {
+				return await createMutation.mutateAsync();
+			} catch (t15$1) {
+				const error = t15$1;
+				console.error("Failed to acquire lock:", error);
+				return null;
+			}
+		};
+		$[34] = createMutation;
+		$[35] = existingLock;
+		$[36] = isOwnSession;
+		$[37] = isOwnUser;
+		$[38] = onBlocked;
+		$[39] = t14;
+	} else t14 = $[39];
+	const acquire = t14;
+	let t15;
+	if ($[40] !== deleteMutation) {
+		t15 = async () => {
+			if (lockIdRef.current) try {
+				await deleteMutation.mutateAsync();
+			} catch (t16$1) {
+				const error_0 = t16$1;
+				console.error("Failed to release lock:", error_0);
+			}
+		};
+		$[40] = deleteMutation;
+		$[41] = t15;
+	} else t15 = $[41];
+	const release = t15;
+	let t16;
+	if ($[42] !== updateMutation) {
+		t16 = async () => {
+			if (lockIdRef.current) try {
+				await updateMutation.mutateAsync();
+			} catch (t17$1) {
+				const error_1 = t17$1;
+				console.error("Failed to refresh lock:", error_1);
+			}
+		};
+		$[42] = updateMutation;
+		$[43] = t16;
+	} else t16 = $[43];
+	const refresh = t16;
+	let t17;
+	let t18;
+	if ($[44] !== acquire || $[45] !== autoAcquire || $[46] !== blockedBy || $[47] !== currentUser || $[48] !== existingLock || $[49] !== isCheckingLock || $[50] !== onBlocked || $[51] !== resourceId) {
+		t17 = () => {
+			if (!autoAcquire || !resourceId || !currentUser || isCheckingLock) return;
+			if (existingLock !== void 0) if (blockedBy) onBlocked?.(blockedBy);
+			else acquire();
+		};
+		t18 = [
+			autoAcquire,
+			resourceId,
+			currentUser,
+			isCheckingLock,
+			existingLock,
+			blockedBy,
+			acquire,
+			onBlocked
+		];
+		$[44] = acquire;
+		$[45] = autoAcquire;
+		$[46] = blockedBy;
+		$[47] = currentUser;
+		$[48] = existingLock;
+		$[49] = isCheckingLock;
+		$[50] = onBlocked;
+		$[51] = resourceId;
+		$[52] = t17;
+		$[53] = t18;
+	} else {
+		t17 = $[52];
+		t18 = $[53];
+	}
+	useEffect(t17, t18);
+	let t19;
+	let t20;
+	if ($[54] !== deleteMutation.mutate) {
+		t19 = () => {
+			const mutate = deleteMutation.mutate;
+			return () => {
+				if (lockIdRef.current) mutate();
+			};
+		};
+		t20 = [deleteMutation.mutate];
+		$[54] = deleteMutation.mutate;
+		$[55] = t19;
+		$[56] = t20;
+	} else {
+		t19 = $[55];
+		t20 = $[56];
+	}
+	useEffect(t19, t20);
+	const t21 = isOwnSession ? existingLock : null;
+	const t22 = isOwnSession && !!existingLock;
+	const t23 = !!blockedBy;
+	const t24 = !!ownLockElsewhere;
+	const t25 = isCheckingLock || createMutation.isPending || updateMutation.isPending || deleteMutation.isPending;
+	let t26;
+	if ($[57] !== acquire || $[58] !== blockedBy || $[59] !== refresh || $[60] !== release || $[61] !== t21 || $[62] !== t22 || $[63] !== t23 || $[64] !== t24 || $[65] !== t25) {
+		t26 = {
+			lock: t21,
+			blockedBy,
+			isLocked: t22,
+			isBlocked: t23,
+			isOpenElsewhere: t24,
+			isPending: t25,
+			acquire,
+			release,
+			refresh
+		};
+		$[57] = acquire;
+		$[58] = blockedBy;
+		$[59] = refresh;
+		$[60] = release;
+		$[61] = t21;
+		$[62] = t22;
+		$[63] = t23;
+		$[64] = t24;
+		$[65] = t25;
+		$[66] = t26;
+	} else t26 = $[66];
+	return t26;
+}
+
+//#endregion
+export { getLockUser, useLock, useLocks };

package/dist/client/hooks/use-media-query.d.mts

@@ -0,0 +1,22 @@
+//#region src/client/hooks/use-media-query.d.ts
+/**
+ * Hook to detect media query matches
+ *
+ * @example
+ * ```tsx
+ * const isMobile = useMediaQuery("(max-width: 768px)");
+ * const isDesktop = useMediaQuery("(min-width: 769px)");
+ * const prefersDark = useMediaQuery("(prefers-color-scheme: dark)");
+ * ```
+ */
+declare function useMediaQuery(query: string): boolean;
+/**
+ * Hook to check if viewport is mobile (below md breakpoint)
+ */
+declare function useIsMobile(): boolean;
+/**
+ * Hook to check if viewport is desktop (md breakpoint and above)
+ */
+declare function useIsDesktop(): boolean;
+//#endregion
+export { useIsDesktop, useIsMobile, useMediaQuery };

package/dist/client/hooks/use-media-query.mjs

@@ -0,0 +1,81 @@
+"use client";
+
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+
+//#region src/client/hooks/use-media-query.ts
+/**
+* Hook to detect media query matches
+*
+* @example
+* ```tsx
+* const isMobile = useMediaQuery("(max-width: 768px)");
+* const isDesktop = useMediaQuery("(min-width: 769px)");
+* const prefersDark = useMediaQuery("(prefers-color-scheme: dark)");
+* ```
+*/
+function useMediaQuery(query) {
+	const $ = c(5);
+	let t0;
+	if ($[0] !== query) {
+		t0 = () => {
+			if (typeof window === "undefined") return false;
+			return window.matchMedia(query).matches;
+		};
+		$[0] = query;
+		$[1] = t0;
+	} else t0 = $[1];
+	const [matches, setMatches] = React.useState(t0);
+	let t1;
+	let t2;
+	if ($[2] !== query) {
+		t1 = () => {
+			if (typeof window === "undefined") return;
+			const mediaQuery = window.matchMedia(query);
+			setMatches(mediaQuery.matches);
+			const listener = (event) => {
+				setMatches(event.matches);
+			};
+			if (mediaQuery.addEventListener) mediaQuery.addEventListener("change", listener);
+			else mediaQuery.addListener(listener);
+			return () => {
+				if (mediaQuery.removeEventListener) mediaQuery.removeEventListener("change", listener);
+				else mediaQuery.removeListener(listener);
+			};
+		};
+		t2 = [query];
+		$[2] = query;
+		$[3] = t1;
+		$[4] = t2;
+	} else {
+		t1 = $[3];
+		t2 = $[4];
+	}
+	React.useEffect(t1, t2);
+	return matches;
+}
+/**
+* Predefined breakpoints matching Tailwind CSS defaults
+*/
+const breakpoints = {
+	sm: "(min-width: 640px)",
+	md: "(min-width: 768px)",
+	lg: "(min-width: 1024px)",
+	xl: "(min-width: 1280px)",
+	"2xl": "(min-width: 1536px)"
+};
+/**
+* Hook to check if viewport is mobile (below md breakpoint)
+*/
+function useIsMobile() {
+	return !useMediaQuery(breakpoints.md);
+}
+/**
+* Hook to check if viewport is desktop (md breakpoint and above)
+*/
+function useIsDesktop() {
+	return useMediaQuery(breakpoints.md);
+}
+
+//#endregion
+export { useIsDesktop, useIsMobile, useMediaQuery };

package/dist/client/hooks/use-prefill-params.mjs

@@ -0,0 +1,47 @@
+import { c } from "react/compiler-runtime";
+import "react";
+
+//#region src/client/hooks/use-prefill-params.ts
+/**
+* Parse prefill parameters from a URLSearchParams object
+*/
+function parsePrefillParams(searchParams) {
+	const prefill = {};
+	for (const [key, value] of searchParams.entries()) if (key.startsWith("prefill.")) {
+		const fieldName = key.slice(8);
+		if (fieldName) try {
+			if (value.startsWith("[") || value.startsWith("{") || value === "true" || value === "false" || value === "null" || !isNaN(Number(value))) prefill[fieldName] = JSON.parse(value);
+			else prefill[fieldName] = value;
+		} catch {
+			prefill[fieldName] = value;
+		}
+	}
+	return prefill;
+}
+/**
+* Build URL with prefill parameters
+*
+* @param baseUrl - Base URL to add params to
+* @param prefillData - Object with field names and values to prefill
+* @returns URL with prefill query params
+*
+* @example
+* ```ts
+* buildPrefillUrl("/admin/collections/barbers/create", { services: "123" })
+* // Returns: "/admin/collections/barbers/create?prefill.services=123"
+*
+* buildPrefillUrl("/admin/collections/posts/create", { tags: ["a", "b"] })
+* // Returns: "/admin/collections/posts/create?prefill.tags=%5B%22a%22%2C%22b%22%5D"
+* ```
+*/
+function buildPrefillUrl(baseUrl, prefillData) {
+	const url = new URL(baseUrl, "http://localhost");
+	for (const [key, value] of Object.entries(prefillData)) if (value !== void 0 && value !== null) {
+		const stringValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+		url.searchParams.set(`prefill.${key}`, stringValue);
+	}
+	return url.pathname + url.search;
+}
+
+//#endregion
+export { buildPrefillUrl, parsePrefillParams };

package/dist/client/hooks/use-questpie-query-options.mjs

@@ -0,0 +1,50 @@
+import { selectClient, useAdminStore } from "../runtime/provider.mjs";
+import { useScopedLocale } from "../runtime/locale-scope.mjs";
+import { c } from "react/compiler-runtime";
+import { useQueryClient } from "@tanstack/react-query";
+import { createQuestpieQueryOptions } from "@questpie/tanstack-query";
+
+//#region src/client/hooks/use-questpie-query-options.ts
+const DEFAULT_KEY_PREFIX = ["questpie", "collections"];
+/**
+* Shared hook that creates questpie query options with the current client and scoped locale.
+* Deduplicates the common pattern used across collection/global hooks.
+*/
+function useQuestpieQueryOptions(t0) {
+	const $ = c(9);
+	const keyPrefix = t0 === void 0 ? DEFAULT_KEY_PREFIX : t0;
+	const client = useAdminStore(selectClient);
+	const { locale } = useScopedLocale();
+	const queryClient = useQueryClient();
+	const t1 = client;
+	let t2;
+	if ($[0] !== keyPrefix || $[1] !== locale || $[2] !== t1) {
+		t2 = createQuestpieQueryOptions(t1, {
+			keyPrefix,
+			locale
+		});
+		$[0] = keyPrefix;
+		$[1] = locale;
+		$[2] = t1;
+		$[3] = t2;
+	} else t2 = $[3];
+	const queryOpts = t2;
+	let t3;
+	if ($[4] !== client || $[5] !== locale || $[6] !== queryClient || $[7] !== queryOpts) {
+		t3 = {
+			queryOpts,
+			queryClient,
+			locale,
+			client
+		};
+		$[4] = client;
+		$[5] = locale;
+		$[6] = queryClient;
+		$[7] = queryOpts;
+		$[8] = t3;
+	} else t3 = $[8];
+	return t3;
+}
+
+//#endregion
+export { useQuestpieQueryOptions };