@questpie/admin 1.1.1 → 3.0.0

package/dist/client/utils/routes.mjs

@@ -0,0 +1,195 @@
+//#region src/client/utils/routes.ts
+/**
+* Create type-safe admin routes from admin config
+*
+* @example
+* ```tsx
+* import { createAdminRoutes } from '@questpie/admin/utils/routes'
+* import { barbershopAdmin } from './configs/admin'
+*
+* const routes = createAdminRoutes(barbershopAdmin)
+*
+* // Type-safe route generation
+* routes.dashboard()                    // "/admin"
+* routes.collections.list('posts')      // "/admin/collections/posts"
+* routes.collections.create('posts')    // "/admin/collections/posts/create"
+* routes.collections.edit('posts', '1') // "/admin/collections/posts/1"
+* routes.globals.edit('siteSettings')   // "/admin/globals/siteSettings"
+* routes.pages.byId('analytics')        // "/admin/analytics" (from page config)
+*
+* // Parse current route
+* const parsed = routes.parse('/admin/collections/posts/123')
+* // { type: 'collection', collection: 'posts', action: 'edit', id: '123' }
+* ```
+*/
+function createAdminRoutes(admin, options = {}) {
+	const basePath = options.basePath ?? "/admin";
+	const pagesConfig = admin.getPages();
+	const pagePathById = {};
+	const pageIdByPath = {};
+	const pageConfigByPath = {};
+	for (const [id, config] of Object.entries(pagesConfig)) {
+		const configPath = config.path ?? id;
+		const pagePath = configPath.startsWith("/") ? configPath.slice(1) : configPath;
+		pagePathById[id] = pagePath;
+		pageIdByPath[pagePath] = id;
+		pageConfigByPath[pagePath] = config;
+	}
+	const joinPath = (...segments) => {
+		return segments.filter(Boolean).join("/");
+	};
+	const collections = {
+		list: (collection) => joinPath(basePath, "collections", collection),
+		create: (collection) => joinPath(basePath, "collections", collection, "create"),
+		edit: (collection, id) => joinPath(basePath, "collections", collection, id),
+		view: (collection, id) => joinPath(basePath, "collections", collection, id),
+		route: (collection, action, id) => {
+			switch (action) {
+				case "list": return collections.list(collection);
+				case "create": return collections.create(collection);
+				case "edit":
+				case "view":
+					if (!id) throw new Error(`ID required for ${action} action`);
+					return collections.edit(collection, id);
+				default: return collections.list(collection);
+			}
+		}
+	};
+	const globals = { edit: (global) => joinPath(basePath, "globals", global) };
+	const pages = {
+		byId: (pageId) => {
+			const pagePath = pagePathById[pageId];
+			if (!pagePath) return null;
+			return joinPath(basePath, pagePath);
+		},
+		all: () => {
+			const result = {};
+			for (const [id, path] of Object.entries(pagePathById)) result[id] = joinPath(basePath, path);
+			return result;
+		},
+		ids: () => Object.keys(pagePathById)
+	};
+	const parse = (pathname) => {
+		const cleanPath = pathname.replace(/\/$/, "");
+		const relativePath = cleanPath.startsWith(basePath) ? cleanPath.slice(basePath.length) : cleanPath;
+		if (relativePath === "" || relativePath === "/") return { type: "dashboard" };
+		const segments = relativePath.split("/").filter(Boolean);
+		if (segments[0] === "collections" && segments[1]) {
+			const collection = segments[1];
+			if (!segments[2]) return {
+				type: "collection",
+				collection,
+				action: "list"
+			};
+			if (segments[2] === "create") return {
+				type: "collection",
+				collection,
+				action: "create"
+			};
+			return {
+				type: "collection",
+				collection,
+				action: "edit",
+				id: segments[2]
+			};
+		}
+		if (segments[0] === "globals" && segments[1]) return {
+			type: "global",
+			global: segments[1]
+		};
+		const pageRelativePath = segments.join("/");
+		if (pageIdByPath[pageRelativePath]) return {
+			type: "page",
+			pageId: pageIdByPath[pageRelativePath],
+			path: pageRelativePath,
+			config: pageConfigByPath[pageRelativePath]
+		};
+		if (pageIdByPath[segments[0]]) return {
+			type: "page",
+			pageId: pageIdByPath[segments[0]],
+			path: segments[0],
+			config: pageConfigByPath[segments[0]]
+		};
+		return {
+			type: "unknown",
+			path: relativePath
+		};
+	};
+	const matches = {
+		dashboard: (pathname) => {
+			return parse(pathname).type === "dashboard";
+		},
+		collection: (pathname, collection) => {
+			const parsed = parse(pathname);
+			if (parsed.type !== "collection") return false;
+			if (collection && parsed.collection !== collection) return false;
+			return true;
+		},
+		global: (pathname, global) => {
+			const parsed = parse(pathname);
+			if (parsed.type !== "global") return false;
+			if (global && parsed.global !== global) return false;
+			return true;
+		},
+		page: (pathname, pageId) => {
+			const parsed = parse(pathname);
+			if (parsed.type !== "page") return false;
+			if (pageId && parsed.pageId !== pageId) return false;
+			return true;
+		}
+	};
+	const withQuery = (path, params) => {
+		return path + buildQueryString(params);
+	};
+	return {
+		basePath,
+		dashboard: () => basePath,
+		collections,
+		globals,
+		pages,
+		parse,
+		matches,
+		withQuery
+	};
+}
+/**
+* Build a query string from params
+*/
+function buildQueryString(params) {
+	const entries = Object.entries(params).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+	return entries.length > 0 ? `?${entries.join("&")}` : "";
+}
+/**
+* Create a navigation helper function
+*
+* @example
+* ```tsx
+* const routes = createAdminRoutes(admin)
+* const go = createNavigator(routes, navigate)
+*
+* // Navigate to routes
+* go.dashboard()
+* go.collection('posts')
+* go.collectionCreate('posts')
+* go.collectionEdit('posts', '123')
+* go.global('siteSettings')
+* go.page('analytics')
+* ```
+*/
+function createNavigator(routes, navigate) {
+	return {
+		dashboard: () => navigate(routes.dashboard()),
+		collection: (collection) => navigate(routes.collections.list(collection)),
+		collectionCreate: (collection) => navigate(routes.collections.create(collection)),
+		collectionEdit: (collection, id) => navigate(routes.collections.edit(collection, id)),
+		global: (global) => navigate(routes.globals.edit(global)),
+		page: (pageId) => {
+			const path = routes.pages.byId(pageId);
+			if (path) navigate(path);
+		},
+		to: (path) => navigate(path)
+	};
+}
+
+//#endregion
+export { createAdminRoutes, createNavigator };

package/dist/client/views/auth/accept-invite-form.d.mts

@@ -0,0 +1,72 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/client/views/auth/accept-invite-form.d.ts
+/**
+ * Accept Invite Form - complete registration after receiving invitation
+ */
+type AcceptInviteFormValues = {
+  name: string;
+  password: string;
+  confirmPassword: string;
+};
+type AcceptInviteFormProps = {
+  /** Called when form is submitted with valid data */
+  onSubmit: (values: AcceptInviteFormValues) => Promise<void>;
+  /** Email from the invitation (display only) */
+  email?: string;
+  /** Additional class name */
+  className?: string;
+  /** Error message from auth */
+  error?: string | null;
+  /** Minimum password length */
+  minPasswordLength?: number;
+};
+/**
+ * Accept invite form for new users to complete registration
+ *
+ * @example
+ * ```tsx
+ * function AcceptInvitePage({ token }: { token: string }) {
+ *   const authClient = useAuthClient()
+ *   const [error, setError] = useState<string | null>(null)
+ *   const [invitation, setInvitation] = useState<any>(null)
+ *
+ *   // Fetch invitation details on mount
+ *   useEffect(() => {
+ *     authClient.admin.getInvitation({ token })
+ *       .then(setInvitation)
+ *       .catch(() => setError('Invalid or expired invitation'))
+ *   }, [token])
+ *
+ *   const handleAccept = async (values: AcceptInviteFormValues) => {
+ *     const result = await authClient.admin.acceptInvitation({
+ *       token,
+ *       name: values.name,
+ *       password: values.password,
+ *     })
+ *     if (result.error) {
+ *       setError(result.error.message)
+ *     } else {
+ *       // Redirect to admin
+ *     }
+ *   }
+ *
+ *   return (
+ *     <AcceptInviteForm
+ *       onSubmit={handleAccept}
+ *       email={invitation?.email}
+ *       error={error}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+declare function AcceptInviteForm({
+  onSubmit,
+  email,
+  className,
+  error,
+  minPasswordLength
+}: AcceptInviteFormProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { AcceptInviteForm };