@questpie/admin 1.1.1 → 3.0.0

package/dist/client/builder/validation.d.mts

@@ -0,0 +1,33 @@
+import { FieldInstance } from "./field/field.mjs";
+import { z } from "zod";
+
+//#region src/client/builder/validation.d.ts
+
+type FieldsMap = Record<string, FieldInstance>;
+interface BuildContext {
+  buildSchema: (fieldDef: FieldInstance) => z.ZodTypeAny;
+}
+/**
+ * Build a Zod schema from a single field's metadata.
+ *
+ * Resolution order:
+ * 1. FIELD_VALIDATORS[type] — special-case fields (email, select, date, relation, etc.)
+ * 2. Generic — resolveBaseType() + applyConstraints() (text, number, boolean, etc.)
+ */
+declare function buildZodFromIntrospection(fieldDef: FieldInstance, ctx: BuildContext): z.ZodTypeAny;
+/**
+ * Build a Zod object schema from a map of field instances.
+ */
+declare function buildValidationSchema(fields: FieldsMap): z.ZodObject<Record<string, z.ZodTypeAny>>;
+/**
+ * Create a Zod validation schema from admin field config.
+ *
+ * @example
+ * ```tsx
+ * const schema = createFormSchema(fieldInstances);
+ * const form = useForm({ resolver: zodResolver(schema) });
+ * ```
+ */
+declare function createFormSchema(fields: FieldsMap): z.ZodTypeAny;
+//#endregion
+export { buildValidationSchema, buildZodFromIntrospection, createFormSchema };

package/dist/client/builder/validation.mjs

@@ -0,0 +1,227 @@
+import { z } from "zod";
+
+//#region src/client/builder/validation.ts
+/**
+* Client-side Validation Schema Builder
+*
+* Centralized Zod schema generation from server field metadata.
+* Server JSON Schema + AJV is the primary validation; this is the Zod fallback
+* used for react-hook-form integration.
+*
+* Three resolution tiers:
+* 1. FIELD_VALIDATORS registry (10 special-case field types)
+* 2. Generic: resolveBaseType() + applyConstraints() (simple field types)
+*/
+function wrapOptional(schema, required) {
+	if (required) return schema;
+	return schema.optional().nullable();
+}
+const FIELD_VALIDATORS = {
+	email: (opts) => {
+		let schema = z.email("Invalid email address");
+		if (opts.maxLength) schema = schema.max(opts.maxLength, `Must be at most ${opts.maxLength} characters`);
+		return wrapOptional(schema, opts.required);
+	},
+	url: (opts) => {
+		let schema = z.url("Invalid URL");
+		if (opts.maxLength) schema = schema.max(opts.maxLength, `Must be at most ${opts.maxLength} characters`);
+		return wrapOptional(schema, opts.required);
+	},
+	select: (opts) => {
+		if (opts.options && opts.options.length > 0) {
+			const validValues = new Set(opts.options.map((o) => o.value));
+			return wrapOptional(z.union([z.string(), z.number()]).refine((val) => validValues.has(val), { message: "Invalid selection" }), opts.required);
+		}
+		return wrapOptional(z.union([z.string(), z.number()]), opts.required);
+	},
+	multiSelect: (opts) => {
+		const validValues = opts.options?.length > 0 ? new Set(opts.options.map((o) => o.value)) : null;
+		const itemSchema = validValues ? z.union([z.string(), z.number()]).refine((val) => validValues.has(val), { message: "Invalid selection" }) : z.union([z.string(), z.number()]);
+		let schema = z.array(itemSchema);
+		if (opts.minItems !== void 0) schema = schema.min(opts.minItems, `Minimum ${opts.minItems} items required`);
+		if (opts.maxItems !== void 0) schema = schema.max(opts.maxItems, `Maximum ${opts.maxItems} items allowed`);
+		return wrapOptional(schema, opts.required);
+	},
+	date: (opts) => {
+		return wrapOptional(z.union([z.date(), z.string().datetime()]).transform((val) => typeof val === "string" ? new Date(val) : val), opts.required);
+	},
+	datetime: (opts) => {
+		return wrapOptional(z.union([z.date(), z.string().datetime()]).transform((val) => typeof val === "string" ? new Date(val) : val), opts.required);
+	},
+	time: (opts) => {
+		return wrapOptional(z.string().regex(/^([01]?[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?$/, "Invalid time format"), opts.required);
+	},
+	relation: (opts) => {
+		if (opts.type === "multiple") {
+			let schema = z.array(z.string());
+			if (opts.maxItems) schema = schema.max(opts.maxItems, `Maximum ${opts.maxItems} items allowed`);
+			return wrapOptional(schema, opts.required);
+		}
+		return wrapOptional(z.string(), opts.required);
+	},
+	upload: (opts) => {
+		if (opts.multiple) {
+			let schema = z.array(z.string());
+			if (opts.maxItems) schema = schema.max(opts.maxItems, `Maximum ${opts.maxItems} files allowed`);
+			return wrapOptional(schema, opts.required);
+		}
+		return wrapOptional(z.string(), opts.required);
+	},
+	object: (opts, ctx) => {
+		if (!opts.fields) return wrapOptional(z.record(z.string(), z.any()), opts.required);
+		const nestedFields = typeof opts.fields === "function" ? opts.fields({}) : opts.fields;
+		const shape = {};
+		for (const [name, fieldDef] of Object.entries(nestedFields)) shape[name] = ctx.buildSchema(fieldDef);
+		return wrapOptional(z.object(shape), opts.required);
+	},
+	array: (opts, ctx) => {
+		let itemSchema;
+		if (opts.item) {
+			const itemFields = typeof opts.item === "function" ? opts.item({}) : opts.item;
+			const shape = {};
+			for (const [name, fieldDef] of Object.entries(itemFields)) shape[name] = ctx.buildSchema(fieldDef);
+			itemSchema = z.object(shape);
+		} else switch (opts.itemType) {
+			case "text":
+			case "textarea":
+				itemSchema = z.string();
+				break;
+			case "number":
+				itemSchema = z.number();
+				break;
+			case "email":
+				itemSchema = z.string().email("Invalid email");
+				break;
+			case "select":
+				if (opts.options?.length > 0) {
+					const validVals = new Set(opts.options.map((o) => o.value));
+					itemSchema = z.union([z.string(), z.number()]).refine((val) => validVals.has(val), { message: "Invalid selection" });
+				} else itemSchema = z.union([z.string(), z.number()]);
+				break;
+			default: itemSchema = z.any();
+		}
+		let schema = z.array(itemSchema);
+		if (opts.minItems !== void 0) schema = schema.min(opts.minItems, `Minimum ${opts.minItems} items required`);
+		if (opts.maxItems !== void 0) schema = schema.max(opts.maxItems, `Maximum ${opts.maxItems} items allowed`);
+		return wrapOptional(schema, opts.required);
+	},
+	blocks: (opts) => {
+		const blockNodeSchema = z.lazy(() => z.object({
+			id: z.string(),
+			type: z.string(),
+			children: z.array(blockNodeSchema)
+		}));
+		let schema = z.object({
+			_tree: z.array(blockNodeSchema),
+			_values: z.record(z.string(), z.record(z.string(), z.any()))
+		});
+		if (opts.minBlocks !== void 0 || opts.maxBlocks !== void 0) schema = schema.refine((data) => {
+			const count = countBlocks(data._tree);
+			if (opts.minBlocks !== void 0 && count < opts.minBlocks) return false;
+			if (opts.maxBlocks !== void 0 && count > opts.maxBlocks) return false;
+			return true;
+		}, { message: opts.minBlocks !== void 0 && opts.maxBlocks !== void 0 ? `Must have between ${opts.minBlocks} and ${opts.maxBlocks} blocks` : opts.minBlocks !== void 0 ? `Minimum ${opts.minBlocks} blocks required` : `Maximum ${opts.maxBlocks} blocks allowed` });
+		return wrapOptional(schema, opts.required);
+	}
+};
+function countBlocks(tree) {
+	let count = 0;
+	for (const node of tree) {
+		count += 1;
+		count += countBlocks(node.children);
+	}
+	return count;
+}
+function resolveBaseType(fieldType) {
+	switch (fieldType) {
+		case "text":
+		case "textarea": return z.string();
+		case "number": return z.number();
+		case "boolean": return z.boolean();
+		case "json":
+		case "richText":
+		case "assetPreview": return z.any();
+		default: return z.any();
+	}
+}
+function applyConstraints(schema, opts) {
+	if (schema instanceof z.ZodString) {
+		let s = schema;
+		if (opts.minLength) s = s.min(opts.minLength, `Must be at least ${opts.minLength} characters`);
+		if (opts.maxLength) s = s.max(opts.maxLength, `Must be at most ${opts.maxLength} characters`);
+		if (opts.pattern) {
+			const regex = typeof opts.pattern === "string" ? new RegExp(opts.pattern) : opts.pattern;
+			s = s.regex(regex, "Invalid format");
+		}
+		return s;
+	}
+	if (schema instanceof z.ZodNumber) {
+		let n = schema;
+		if (opts.min !== void 0) n = n.min(opts.min, `Must be at least ${opts.min}`);
+		if (opts.max !== void 0) n = n.max(opts.max, `Must be at most ${opts.max}`);
+		return n;
+	}
+	return schema;
+}
+/**
+* Build a Zod schema from a single field's metadata.
+*
+* Resolution order:
+* 1. FIELD_VALIDATORS[type] — special-case fields (email, select, date, relation, etc.)
+* 2. Generic — resolveBaseType() + applyConstraints() (text, number, boolean, etc.)
+*/
+function buildZodFromIntrospection(fieldDef, ctx) {
+	const opts = fieldDef["~options"] || {};
+	const validator = FIELD_VALIDATORS[fieldDef.name];
+	if (validator) return validator(opts, ctx);
+	return wrapOptional(applyConstraints(resolveBaseType(fieldDef.name), opts), opts.required);
+}
+/**
+* Build a Zod object schema from a map of field instances.
+*/
+function buildValidationSchema(fields) {
+	const ctx = { buildSchema: (fieldDef) => buildZodFromIntrospection(fieldDef, ctx) };
+	const shape = {};
+	for (const [name, fieldDef] of Object.entries(fields)) shape[name] = ctx.buildSchema(fieldDef);
+	return z.object(shape);
+}
+/**
+* Build validation schema with custom cross-field validators.
+*/
+function buildValidationSchemaWithCustom(fields) {
+	const baseSchema = buildValidationSchema(fields);
+	const customValidators = [];
+	for (const [name, fieldDef] of Object.entries(fields)) {
+		const options = fieldDef["~options"] || {};
+		if (options.validation?.validate) customValidators.push({
+			name,
+			validate: options.validation.validate
+		});
+	}
+	if (customValidators.length === 0) return baseSchema;
+	return baseSchema.superRefine((data, ctx) => {
+		for (const { name, validate } of customValidators) {
+			const error = validate(data[name], data);
+			if (error) ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: error,
+				path: [name]
+			});
+		}
+	});
+}
+/**
+* Create a Zod validation schema from admin field config.
+*
+* @example
+* ```tsx
+* const schema = createFormSchema(fieldInstances);
+* const form = useForm({ resolver: zodResolver(schema) });
+* ```
+*/
+function createFormSchema(fields) {
+	return buildValidationSchemaWithCustom(fields);
+}
+
+//#endregion
+export { buildValidationSchema, buildZodFromIntrospection, createFormSchema };

package/dist/client/builder/view/view.d.mts

@@ -0,0 +1,49 @@
+import { MaybeLazyComponent } from "../types/common.mjs";
+
+//#region src/client/builder/view/view.d.ts
+
+/**
+ * View kind discriminant — "list" for collection list pages, "form" for edit/create pages.
+ */
+type ViewKind = "list" | "form";
+/**
+ * View definition — a registry entry mapping a view name to its component.
+ *
+ * Created by the `view()` factory. Has `kind` discriminant for list vs form views.
+ * All view config (columns, sections, etc.) flows from server introspection.
+ */
+interface ViewDefinition<TName extends string = string, TKind extends ViewKind = ViewKind> {
+  readonly name: TName;
+  readonly kind: TKind;
+  readonly component: MaybeLazyComponent;
+}
+/**
+ * List view definition
+ */
+type ListViewDefinition<TName extends string = string> = ViewDefinition<TName, "list">;
+/**
+ * Form view definition
+ */
+type FormViewDefinition<TName extends string = string> = ViewDefinition<TName, "form">;
+/**
+ * Create a view definition as a plain frozen object.
+ *
+ * @example
+ * ```ts
+ * export default view("collection-table", {
+ *   kind: "list",
+ *   component: () => import("./table-view.js"),
+ * });
+ *
+ * export default view("collection-form", {
+ *   kind: "form",
+ *   component: () => import("./form-view.js"),
+ * });
+ * ```
+ */
+declare function view<TName extends string, TKind extends ViewKind>(name: TName, options: {
+  kind: TKind;
+  component: MaybeLazyComponent;
+}): ViewDefinition<TName, TKind>;
+//#endregion
+export { FormViewDefinition, ListViewDefinition, ViewDefinition, ViewKind, view };

package/dist/client/builder/view/view.mjs

@@ -0,0 +1,27 @@
+//#region src/client/builder/view/view.ts
+/**
+* Create a view definition as a plain frozen object.
+*
+* @example
+* ```ts
+* export default view("collection-table", {
+*   kind: "list",
+*   component: () => import("./table-view.js"),
+* });
+*
+* export default view("collection-form", {
+*   kind: "form",
+*   component: () => import("./form-view.js"),
+* });
+* ```
+*/
+function view(name, options) {
+	return Object.freeze({
+		name,
+		kind: options.kind,
+		component: options.component
+	});
+}
+
+//#endregion
+export { view };

package/dist/client/builder/widget/widget.d.mts

@@ -0,0 +1,27 @@
+import { MaybeLazyComponent } from "../types/common.mjs";
+
+//#region src/client/builder/widget/widget.d.ts
+
+/**
+ * Widget definition — a plain frozen object describing a dashboard widget.
+ */
+interface WidgetDefinition<TName extends string = string> {
+  readonly name: TName;
+  readonly component: MaybeLazyComponent;
+}
+/**
+ * Create a dashboard widget as a plain frozen object.
+ *
+ * @example
+ * ```ts
+ * // Generated by `questpie generate`:
+ * export default widget("stats", {
+ *   component: () => import("./stats-widget.js"),
+ * });
+ * ```
+ */
+declare function widget<TName extends string, TComponent extends MaybeLazyComponent>(name: TName, config: {
+  component: TComponent;
+}): WidgetDefinition<TName>;
+//#endregion
+export { WidgetDefinition, widget };

package/dist/client/builder/widget/widget.mjs

@@ -0,0 +1,21 @@
+//#region src/client/builder/widget/widget.ts
+/**
+* Create a dashboard widget as a plain frozen object.
+*
+* @example
+* ```ts
+* // Generated by `questpie generate`:
+* export default widget("stats", {
+*   component: () => import("./stats-widget.js"),
+* });
+* ```
+*/
+function widget(name, config) {
+	return Object.freeze({
+		name,
+		component: config.component
+	});
+}
+
+//#endregion
+export { widget };

package/dist/client/components/actions/action-button.mjs

@@ -0,0 +1,245 @@
+"use client";
+
+import { useResolveText, useTranslation } from "../../i18n/hooks.mjs";
+import { selectAuthClient, useAdminStore } from "../../runtime/provider.mjs";
+import { resolveIconElement } from "../component-renderer.mjs";
+import { Button } from "../ui/button.mjs";
+import { ConfirmationDialog } from "./confirmation-dialog.mjs";
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/client/components/actions/action-button.tsx
+/**
+* Action Button
+*
+* A button component that renders an action with optional confirmation dialog.
+* Handles different action types (navigate, api, custom, dialog, form).
+*/
+/**
+* ActionButton - Renders an action button with confirmation support
+*
+* @example
+* ```tsx
+* <ActionButton
+*   action={deleteAction}
+*   collection="posts"
+*   item={post}
+*   helpers={actionHelpers}
+* />
+* ```
+*/
+function ActionButton(t0) {
+	const $ = c(47);
+	const { action, collection, item, items, helpers, size: t1, className, iconOnly: t2, onOpenDialog } = t0;
+	const size = t1 === void 0 ? "default" : t1;
+	const iconOnly = t2 === void 0 ? false : t2;
+	const resolveText = useResolveText();
+	const { t } = useTranslation();
+	const authClient = useAdminStore(selectAuthClient);
+	const queryClient = useQueryClient();
+	const [showConfirm, setShowConfirm] = React.useState(false);
+	const [isLoading, setIsLoading] = React.useState(false);
+	let t3;
+	if ($[0] !== queryClient) {
+		t3 = {
+			invalidateQueries: (filters) => queryClient.invalidateQueries(filters),
+			refetchQueries: (filters_0) => queryClient.refetchQueries(filters_0),
+			resetQueries: (filters_1) => queryClient.resetQueries(filters_1)
+		};
+		$[0] = queryClient;
+		$[1] = t3;
+	} else t3 = $[1];
+	const actionQueryClient = t3;
+	let t4;
+	if ($[2] !== actionQueryClient || $[3] !== authClient || $[4] !== collection || $[5] !== helpers || $[6] !== item || $[7] !== items) {
+		t4 = {
+			item,
+			items,
+			collection,
+			helpers,
+			queryClient: actionQueryClient,
+			authClient
+		};
+		$[2] = actionQueryClient;
+		$[3] = authClient;
+		$[4] = collection;
+		$[5] = helpers;
+		$[6] = item;
+		$[7] = items;
+		$[8] = t4;
+	} else t4 = $[8];
+	const ctx = t4;
+	let t5;
+	bb0: {
+		if (action.visible === void 0) {
+			t5 = true;
+			break bb0;
+		}
+		if (typeof action.visible === "function") {
+			t5 = action.visible(ctx);
+			break bb0;
+		}
+		t5 = action.visible;
+	}
+	const isVisible = t5;
+	let t6;
+	bb1: {
+		if (action.disabled === void 0) {
+			t6 = false;
+			break bb1;
+		}
+		if (typeof action.disabled === "function") {
+			let t7$1;
+			if ($[9] !== action || $[10] !== ctx) {
+				t7$1 = action.disabled(ctx);
+				$[9] = action;
+				$[10] = ctx;
+				$[11] = t7$1;
+			} else t7$1 = $[11];
+			t6 = t7$1;
+			break bb1;
+		}
+		t6 = action.disabled;
+	}
+	const isDisabled = t6;
+	if (!isVisible) return null;
+	let t7;
+	if ($[12] !== action || $[13] !== collection || $[14] !== ctx || $[15] !== helpers || $[16] !== item || $[17] !== onOpenDialog || $[18] !== t) {
+		t7 = async () => {
+			const { handler } = action;
+			bb39: switch (handler.type) {
+				case "navigate": {
+					const path = typeof handler.path === "function" ? handler.path(item) : handler.path;
+					helpers.navigate(`${helpers.basePath}/collections/${collection}/${path}`);
+					break bb39;
+				}
+				case "api": {
+					setIsLoading(true);
+					const itemAny = item;
+					const itemId = itemAny != null ? String(itemAny.id) : "";
+					const method = handler.method ? handler.method : "POST";
+					const endpoint = handler.endpoint.replace("{id}", itemId);
+					try {
+						helpers.toast.info(`API call: ${method} ${endpoint}`);
+						helpers.refresh();
+						setIsLoading(false);
+					} catch (t8$1) {
+						helpers.toast.error(t("error.actionFailed"));
+						setIsLoading(false);
+					}
+					break bb39;
+				}
+				case "custom":
+					setIsLoading(true);
+					try {
+						await handler.fn(ctx);
+						setIsLoading(false);
+					} catch (t9$1) {
+						helpers.toast.error(t("error.actionFailed"));
+						setIsLoading(false);
+					}
+					break bb39;
+				case "dialog":
+				case "form":
+					onOpenDialog?.(action);
+					break bb39;
+				case "server": onOpenDialog?.(action);
+			}
+		};
+		$[12] = action;
+		$[13] = collection;
+		$[14] = ctx;
+		$[15] = helpers;
+		$[16] = item;
+		$[17] = onOpenDialog;
+		$[18] = t;
+		$[19] = t7;
+	} else t7 = $[19];
+	const executeAction = t7;
+	let t8;
+	if ($[20] !== action.confirmation || $[21] !== executeAction) {
+		t8 = (e) => {
+			e.stopPropagation();
+			if (action.confirmation) setShowConfirm(true);
+			else executeAction();
+		};
+		$[20] = action.confirmation;
+		$[21] = executeAction;
+		$[22] = t8;
+	} else t8 = $[22];
+	const handleClick = t8;
+	let t9;
+	if ($[23] !== executeAction) {
+		t9 = async () => {
+			await executeAction();
+		};
+		$[23] = executeAction;
+		$[24] = t9;
+	} else t9 = $[24];
+	const handleConfirm = t9;
+	let t10;
+	if ($[25] !== action.icon) {
+		t10 = resolveIconElement(action.icon, { "data-icon": "inline-start" });
+		$[25] = action.icon;
+		$[26] = t10;
+	} else t10 = $[26];
+	const iconElement = t10;
+	const t11 = action.variant || "default";
+	const t12 = iconOnly ? "icon-sm" : size;
+	const t13 = isDisabled || isLoading;
+	let t14;
+	if ($[27] !== action.label || $[28] !== iconOnly || $[29] !== resolveText) {
+		t14 = !iconOnly && resolveText(action.label);
+		$[27] = action.label;
+		$[28] = iconOnly;
+		$[29] = resolveText;
+		$[30] = t14;
+	} else t14 = $[30];
+	let t15;
+	if ($[31] !== className || $[32] !== handleClick || $[33] !== iconElement || $[34] !== t11 || $[35] !== t12 || $[36] !== t13 || $[37] !== t14) {
+		t15 = /* @__PURE__ */ jsxs(Button, {
+			variant: t11,
+			size: t12,
+			onClick: handleClick,
+			disabled: t13,
+			className,
+			children: [iconElement, t14]
+		});
+		$[31] = className;
+		$[32] = handleClick;
+		$[33] = iconElement;
+		$[34] = t11;
+		$[35] = t12;
+		$[36] = t13;
+		$[37] = t14;
+		$[38] = t15;
+	} else t15 = $[38];
+	let t16;
+	if ($[39] !== action.confirmation || $[40] !== handleConfirm || $[41] !== isLoading || $[42] !== showConfirm) {
+		t16 = action.confirmation && /* @__PURE__ */ jsx(ConfirmationDialog, {
+			open: showConfirm,
+			onOpenChange: setShowConfirm,
+			config: action.confirmation,
+			onConfirm: handleConfirm,
+			loading: isLoading
+		});
+		$[39] = action.confirmation;
+		$[40] = handleConfirm;
+		$[41] = isLoading;
+		$[42] = showConfirm;
+		$[43] = t16;
+	} else t16 = $[43];
+	let t17;
+	if ($[44] !== t15 || $[45] !== t16) {
+		t17 = /* @__PURE__ */ jsxs(Fragment, { children: [t15, t16] });
+		$[44] = t15;
+		$[45] = t16;
+		$[46] = t17;
+	} else t17 = $[46];
+	return t17;
+}
+
+//#endregion
+export { ActionButton };