@questpie/admin 2.0.0 → 3.0.1

package/dist/client/builder/validation.mjs

@@ -1,149 +1,195 @@
-import { createFieldRegistryProxy } from "./proxies.mjs";
 import { z } from "zod";
 
 //#region src/client/builder/validation.ts
 /**
 * Client-side Validation Schema Builder
 *
-* Generates Zod schemas from admin field configurations.
-* Uses createZod from field definitions for automatic schema generation.
-* Supports nested fields (object, array) via recursive schema building.
-*/
-/**
-* Build a string schema with validations (fallback)
+* 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 buildStringSchema(validation) {
-	let schema = z.string();
-	if (validation) {
-		if (validation.minLength !== void 0) schema = schema.min(validation.minLength, `Must be at least ${validation.minLength} characters`);
-		if (validation.maxLength !== void 0) schema = schema.max(validation.maxLength, `Must be at most ${validation.maxLength} characters`);
-		if (validation.email) schema = schema.email("Invalid email address");
-		if (validation.url) schema = schema.url("Invalid URL");
-		if (validation.pattern) {
-			const regex = typeof validation.pattern === "string" ? new RegExp(validation.pattern) : validation.pattern;
-			schema = schema.regex(regex, validation.patternMessage || "Invalid format");
+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);
 	}
-	return schema;
-}
-/**
-* Build a number schema with validations (fallback)
-*/
-function buildNumberSchema(validation) {
-	let schema = z.number();
-	if (validation) {
-		if (validation.min !== void 0) schema = schema.min(validation.min, `Must be at least ${validation.min}`);
-		if (validation.max !== void 0) schema = schema.max(validation.max, `Must be at most ${validation.max}`);
+};
+function countBlocks(tree) {
+	let count = 0;
+	for (const node of tree) {
+		count += 1;
+		count += countBlocks(node.children);
 	}
-	return schema;
+	return count;
 }
-/**
-* Fallback schema builder for fields without createZod
-*/
-function buildFallbackSchema(fieldType, required, validation) {
-	let schema;
+function resolveBaseType(fieldType) {
 	switch (fieldType) {
 		case "text":
-		case "textarea":
-		case "email":
-		case "password":
-		case "slug":
-		case "code":
-		case "time":
-			schema = buildStringSchema(validation);
-			break;
-		case "number":
-		case "currency":
-			schema = buildNumberSchema(validation);
-			break;
-		case "switch":
-		case "checkbox":
-			schema = z.boolean();
-			break;
-		case "date":
-		case "datetime":
-			schema = z.date().or(z.string());
-			break;
-		case "select":
-			schema = z.string().or(z.number());
-			break;
-		case "relation":
-			schema = z.string().or(z.array(z.string()));
-			break;
-		case "upload":
-			schema = z.string();
-			break;
-		case "uploadMany":
-			schema = z.array(z.string());
-			break;
-		case "array":
-			schema = z.array(z.any());
-			break;
-		case "object":
-			schema = z.record(z.string(), z.any());
-			break;
+		case "textarea": return z.string();
+		case "number": return z.number();
+		case "boolean": return z.boolean();
 		case "json":
 		case "richText":
-			schema = z.any();
-			break;
-		default: schema = z.any();
+		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;
 	}
-	if (validation?.refine) schema = validation.refine(schema);
-	if (!required) schema = schema.optional().nullable();
 	return schema;
 }
 /**
-* Creates the ZodBuildContext for recursive schema building
+* 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 createBuildContext(registry) {
-	const ctx = {
-		registry,
-		buildSchema: (fieldDef) => {
-			const opts = fieldDef["~options"] || {};
-			if (fieldDef.createZod) return fieldDef.createZod(opts, ctx);
-			return buildFallbackSchema(fieldDef.name, opts.required, opts.validation);
-		}
-	};
-	return ctx;
+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 schema from admin field definitions
-*
-* Uses createZod from each field definition if available,
-* otherwise falls back to generic schema based on field type.
-*
-* @param fields - Field definitions from admin collection config
-* @param registry - Field registry from admin builder
-* @returns Zod object schema for the collection
-*
-* @example
-* ```ts
-* const schema = buildValidationSchema(collectionConfig.fields, admin.getFields());
-*
-* // Use with react-hook-form
-* const form = useForm({
-*   resolver: zodResolver(schema),
-* });
-* ```
+* Build a Zod object schema from a map of field instances.
 */
-function buildValidationSchema(fields, registry) {
-	const ctx = createBuildContext(registry);
+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 validation functions
-*
-* This version supports the `validate` callback in FieldValidationConfig
-* which receives form values for cross-field validation.
-*
-* @param fields - Field definitions from admin collection config
-* @param registry - Field registry from admin builder
-* @returns Zod schema with superRefine for custom validators
+* Build validation schema with custom cross-field validators.
 */
-function buildValidationSchemaWithCustom(fields, registry) {
-	const baseSchema = buildValidationSchema(fields, registry);
+function buildValidationSchemaWithCustom(fields) {
+	const baseSchema = buildValidationSchema(fields);
 	const customValidators = [];
 	for (const [name, fieldDef] of Object.entries(fields)) {
 		const options = fieldDef["~options"] || {};
@@ -165,44 +211,17 @@ function buildValidationSchemaWithCustom(fields, registry) {
 	});
 }
 /**
-* Create a Zod validation schema from admin field config
-*
-* Use with @hookform/resolvers/zod for react-hook-form integration.
-*
-* @param fields - Field definitions from admin collection config
-* @param registry - Field registry from admin builder
-* @returns Zod schema for form validation
+* Create a Zod validation schema from admin field config.
 *
 * @example
 * ```tsx
-* import { zodResolver } from "@hookform/resolvers/zod";
-* import { createFormSchema } from "@questpie/admin/builder";
-*
-* // From collection config
-* const schema = createFormSchema(collectionConfig.fields, admin.getFields());
-*
-* function MyForm() {
-*   const form = useForm({
-*     resolver: zodResolver(schema),
-*   });
-*   // ...
-* }
-*
-* // Or use the hook
-* import { useCollectionValidation } from "@questpie/admin/hooks";
-*
-* function MyCollectionForm() {
-*   const schema = useCollectionValidation("posts");
-*   const form = useForm({
-*     resolver: schema ? zodResolver(schema) : undefined,
-*   });
-* }
+* const schema = createFormSchema(fieldInstances);
+* const form = useForm({ resolver: zodResolver(schema) });
 * ```
 */
-function createFormSchema(fields, registry) {
-	return buildValidationSchemaWithCustom(fields, registry);
+function createFormSchema(fields) {
+	return buildValidationSchemaWithCustom(fields);
 }
 
 //#endregion
-export { buildValidationSchema, createFormSchema };
-//# sourceMappingURL=validation.mjs.map
+export { buildValidationSchema, buildZodFromIntrospection, createFormSchema };

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

@@ -1,129 +1,49 @@
 import { MaybeLazyComponent } from "../types/common.mjs";
-import { SetProperty } from "questpie/shared";
 
 //#region src/client/builder/view/view.d.ts
 
 /**
- * Extract viewConfig type from a view component's props.
- *
- * Looks for `viewConfig?: T` prop and extracts T.
- * Returns `unknown` if not found (will be refined by $config).
- */
-type ExtractViewConfigFromComponent<TComponent> = TComponent extends React.ComponentType<infer P> ? P extends {
-  viewConfig?: infer C;
-} ? C : unknown : unknown;
-/**
- * Extract config from lazy component: () => Promise<{ default: Component }>
- */
-type ExtractViewConfigFromLazy<TComponent> = TComponent extends (() => Promise<{
-  default: infer C;
-}>) ? ExtractViewConfigFromComponent<C> : ExtractViewConfigFromComponent<TComponent>;
-/**
- * List view definition
+ * View kind discriminant — "list" for collection list pages, "form" for edit/create pages.
  */
-interface ListViewDefinition<TName extends string = string, TConfig = unknown> {
-  readonly name: TName;
-  readonly kind: "list";
-  readonly "~config": TConfig;
-  readonly component: MaybeLazyComponent;
-}
+type ViewKind = "list" | "form";
 /**
- * Edit view definition
+ * 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 EditViewDefinition<TName extends string = string, TConfig = unknown> {
+interface ViewDefinition<TName extends string = string, TKind extends ViewKind = ViewKind> {
   readonly name: TName;
-  readonly kind: "edit";
-  readonly "~config": TConfig;
-  readonly component: MaybeLazyComponent;
-}
-interface ListViewBuilderState<TConfig = unknown> {
-  readonly name: string;
-  readonly kind: "list";
-  readonly "~config": TConfig;
-  readonly component: MaybeLazyComponent;
-}
-interface EditViewBuilderState<TConfig = unknown> {
-  readonly name: string;
-  readonly kind: "edit";
-  readonly "~config": TConfig;
+  readonly kind: TKind;
   readonly component: MaybeLazyComponent;
 }
 /**
- * List view builder - implements ListViewDefinition for unified type handling
+ * List view definition
  */
-declare class ListViewBuilder<TState extends ListViewBuilderState> implements ListViewDefinition<TState["name"], TState["~config"]> {
-  readonly state: TState;
-  constructor(state: TState);
-  get name(): TState["name"];
-  get kind(): "list";
-  get "~config"(): TState["~config"];
-  get component(): TState["component"];
-  /**
-   * Set or override config value and type.
-   *
-   * @param config - Optional config value (for runtime) or omit for type-only override
-   */
-  $config<TNewConfig>(config?: TNewConfig): ListViewBuilder<SetProperty<TState, "~config", TNewConfig>>;
-}
+type ListViewDefinition<TName extends string = string> = ViewDefinition<TName, "list">;
 /**
- * Edit view builder - implements EditViewDefinition for unified type handling
+ * Form view definition
  */
-declare class EditViewBuilder<TState extends EditViewBuilderState> implements EditViewDefinition<TState["name"], TState["~config"]> {
-  readonly state: TState;
-  constructor(state: TState);
-  get name(): TState["name"];
-  get kind(): "edit";
-  get "~config"(): TState["~config"];
-  get component(): TState["component"];
-  /**
-   * Set or override config value and type.
-   *
-   * @param config - Optional config value (for runtime) or omit for type-only override
-   */
-  $config<TNewConfig>(config?: TNewConfig): EditViewBuilder<SetProperty<TState, "~config", TNewConfig>>;
-}
+type FormViewDefinition<TName extends string = string> = ViewDefinition<TName, "form">;
 /**
- * Create a list view with automatic config type extraction.
- *
- * The config type is extracted from the component's `viewConfig` prop.
- * If extraction fails, use `.$config<MyConfigType>()` to set it manually.
+ * Create a view definition as a plain frozen object.
  *
  * @example
  * ```ts
- * // Auto-extraction from component props
- * const tableView = listView("table", { component: TableView });
- * // ^? ListViewBuilder<{ ~config: TableViewConfig }>
+ * export default view("collection-table", {
+ *   kind: "list",
+ *   component: () => import("./table-view.js"),
+ * });
  *
- * // Manual config type for lazy imports
- * const lazyTable = listView("table", { component: () => import('./TableView') })
- *   .$config<TableViewConfig>();
- * ```
- */
-declare function listView<TName extends string, TComponent extends MaybeLazyComponent>(name: TName, config: {
-  component: TComponent;
-}): ListViewBuilder<{
-  name: TName;
-  kind: "list";
-  "~config": ExtractViewConfigFromLazy<TComponent>;
-  component: TComponent;
-}>;
-/**
- * Create an edit view with automatic config type extraction.
- *
- * @example
- * ```ts
- * const formView = editView("form", { component: FormView });
- * // ^? EditViewBuilder<{ ~config: FormViewRegistryConfig }>
+ * export default view("collection-form", {
+ *   kind: "form",
+ *   component: () => import("./form-view.js"),
+ * });
  * ```
  */
-declare function editView<TName extends string, TComponent extends MaybeLazyComponent>(name: TName, config: {
-  component: TComponent;
-}): EditViewBuilder<{
-  name: TName;
-  kind: "edit";
-  "~config": ExtractViewConfigFromLazy<TComponent>;
-  component: TComponent;
-}>;
+declare function view<TName extends string, TKind extends ViewKind>(name: TName, options: {
+  kind: TKind;
+  component: MaybeLazyComponent;
+}): ViewDefinition<TName, TKind>;
 //#endregion
-export { EditViewBuilder, EditViewBuilderState, EditViewDefinition, ListViewBuilder, ListViewBuilderState, ListViewDefinition, editView, listView };
-//# sourceMappingURL=view.d.mts.map
+export { FormViewDefinition, ListViewDefinition, ViewDefinition, ViewKind, view };

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

@@ -1,109 +1,27 @@
 //#region src/client/builder/view/view.ts
 /**
-* List view builder - implements ListViewDefinition for unified type handling
-*/
-var ListViewBuilder = class ListViewBuilder {
-	constructor(state) {
-		this.state = state;
-	}
-	get name() {
-		return this.state.name;
-	}
-	get kind() {
-		return "list";
-	}
-	get "~config"() {
-		return this.state["~config"];
-	}
-	get component() {
-		return this.state.component;
-	}
-	/**
-	* Set or override config value and type.
-	*
-	* @param config - Optional config value (for runtime) or omit for type-only override
-	*/
-	$config(config) {
-		return new ListViewBuilder({
-			...this.state,
-			"~config": config ?? this.state["~config"]
-		});
-	}
-};
-/**
-* Edit view builder - implements EditViewDefinition for unified type handling
-*/
-var EditViewBuilder = class EditViewBuilder {
-	constructor(state) {
-		this.state = state;
-	}
-	get name() {
-		return this.state.name;
-	}
-	get kind() {
-		return "edit";
-	}
-	get "~config"() {
-		return this.state["~config"];
-	}
-	get component() {
-		return this.state.component;
-	}
-	/**
-	* Set or override config value and type.
-	*
-	* @param config - Optional config value (for runtime) or omit for type-only override
-	*/
-	$config(config) {
-		return new EditViewBuilder({
-			...this.state,
-			"~config": config ?? this.state["~config"]
-		});
-	}
-};
-/**
-* Create a list view with automatic config type extraction.
-*
-* The config type is extracted from the component's `viewConfig` prop.
-* If extraction fails, use `.$config<MyConfigType>()` to set it manually.
+* Create a view definition as a plain frozen object.
 *
 * @example
 * ```ts
-* // Auto-extraction from component props
-* const tableView = listView("table", { component: TableView });
-* // ^? ListViewBuilder<{ ~config: TableViewConfig }>
-*
-* // Manual config type for lazy imports
-* const lazyTable = listView("table", { component: () => import('./TableView') })
-*   .$config<TableViewConfig>();
-* ```
-*/
-function listView(name, config) {
-	return new ListViewBuilder({
-		name,
-		kind: "list",
-		"~config": {},
-		component: config.component
-	});
-}
-/**
-* Create an edit view with automatic config type extraction.
+* export default view("collection-table", {
+*   kind: "list",
+*   component: () => import("./table-view.js"),
+* });
 *
-* @example
-* ```ts
-* const formView = editView("form", { component: FormView });
-* // ^? EditViewBuilder<{ ~config: FormViewRegistryConfig }>
+* export default view("collection-form", {
+*   kind: "form",
+*   component: () => import("./form-view.js"),
+* });
 * ```
 */
-function editView(name, config) {
-	return new EditViewBuilder({
+function view(name, options) {
+	return Object.freeze({
 		name,
-		kind: "edit",
-		"~config": {},
-		component: config.component
+		kind: options.kind,
+		component: options.component
 	});
 }
 
 //#endregion
-export { EditViewBuilder, ListViewBuilder, editView, listView };
-//# sourceMappingURL=view.mjs.map
+export { view };