@questpie/admin 1.1.0 → 2.0.0

package/dist/server/patch.mjs

@@ -0,0 +1,1062 @@
+import { BlockBuilder } from "./block/block-builder.mjs";
+import { createBlocksPrefetchHook } from "./block/prefetch.mjs";
+import { CollectionBuilder, GlobalBuilder, QuestpieBuilder, createFieldBuilder, createFieldDefinition } from "questpie";
+
+//#region src/server/patch.ts
+/**
+* Runtime Monkey Patching for Admin Builder Methods
+*
+* This module patches QuestpieBuilder, CollectionBuilder, and GlobalBuilder
+* with admin-specific methods when adminModule is used.
+*
+* The patches add these methods:
+* - QuestpieBuilder: listView(), editView(), component(), listViews(), editViews(), components()
+* - CollectionBuilder: admin(), list(), form(), preview()
+* - GlobalBuilder: admin(), form()
+*
+* Type augmentation is handled by ./augmentation.ts which extends the builder types.
+*
+* @internal This module is automatically imported by adminModule.
+*/
+let patchesApplied = false;
+/**
+* Resolve registry source state.
+*
+* - Collection/Global builders: registry lives on `state["~questpieApp"].state`
+* - QuestpieBuilder: registry lives on `state`
+*/
+function getRegistrySourceState(builderState) {
+	const questpieApp = builderState["~questpieApp"];
+	if (questpieApp?.state && typeof questpieApp.state === "object") return questpieApp.state;
+	return builderState;
+}
+/**
+* Resolve registered component names from builder state.
+*/
+function getRegisteredComponentNames(builderState) {
+	const components = getRegistrySourceState(builderState).components;
+	if (!components || typeof components !== "object") return [];
+	return Object.keys(components);
+}
+/**
+* Normalize component props into a serializable object.
+*
+* Backward compatibility:
+* - `c.icon("ph:users")` => `{ name: "ph:users" }`
+*/
+function normalizeComponentProps(componentType, props) {
+	if (componentType === "icon" && typeof props === "string") return { name: props };
+	if (props === null || props === void 0) return {};
+	if (typeof props === "object") return props;
+	return { value: props };
+}
+/**
+* Create a component proxy for registered component references.
+* Used in admin config functions (`.admin()`, `.actions()`, `.dashboard()`, `.sidebar()`).
+*
+* @example
+* ```ts
+* .admin(({ c }) => ({
+*   icon: c.icon("ph:users"),
+*   badge: c.badge({ text: "New", color: "green" }),
+* }))
+* ```
+*/
+function createComponentProxy(builderState) {
+	const componentNames = getRegisteredComponentNames(builderState);
+	const registeredComponentSet = new Set(componentNames);
+	return new Proxy({}, {
+		get: (_target, prop) => {
+			if (typeof prop !== "string") return;
+			if (prop === "then") return;
+			if (registeredComponentSet.size === 0) throw new Error("No components registered. Register components via .components() or use q.use(adminModule) defaults.");
+			if (!registeredComponentSet.has(prop)) throw new Error(`Unknown component "${prop}". Register it via .components(). Available components: ${[...registeredComponentSet].sort().join(", ")}`);
+			return (props) => ({
+				type: prop,
+				props: normalizeComponentProps(prop, props)
+			});
+		},
+		has: (_target, prop) => {
+			if (typeof prop !== "string") return false;
+			return registeredComponentSet.has(prop);
+		},
+		ownKeys: () => [...registeredComponentSet],
+		getOwnPropertyDescriptor: (_target, prop) => {
+			if (typeof prop !== "string") return;
+			if (!registeredComponentSet.has(prop)) return;
+			return {
+				configurable: true,
+				enumerable: true,
+				writable: false,
+				value: (props) => ({
+					type: prop,
+					props: normalizeComponentProps(prop, props)
+				})
+			};
+		}
+	});
+}
+/**
+* Create a field proxy for referencing collection fields.
+* Returns field names as strings for config objects.
+*
+* @example
+* ```ts
+* .list(({ f }) => ({
+*   columns: [f.title, f.author, f.createdAt],
+* }))
+* ```
+*/
+function createFieldProxy(fieldNames) {
+	return new Proxy({}, {
+		get: (_target, prop) => prop,
+		has: (_target, prop) => fieldNames.includes(prop),
+		ownKeys: () => fieldNames,
+		getOwnPropertyDescriptor: (_target, prop) => {
+			if (fieldNames.includes(prop)) return {
+				configurable: true,
+				enumerable: true,
+				value: prop
+			};
+		}
+	});
+}
+/**
+* Create a view proxy for defining view configurations.
+*
+* If the builder is bound to a Questpie app with registered views
+* (`.listViews()` / `.editViews()`), the proxy only allows those names.
+* If no registry is available (standalone builders), any view name is allowed.
+*
+* @example
+* ```ts
+* .list(({ v }) => v.table({
+*   columns: [...],
+*   defaultSort: { field: "createdAt", direction: "desc" },
+* }))
+* ```
+*/
+function createViewProxy(kind, registeredViews = []) {
+	const registeredViewSet = new Set(registeredViews);
+	const hasRegistry = registeredViewSet.size > 0;
+	return new Proxy({}, {
+		get: (_target, prop) => {
+			if (typeof prop !== "string") return;
+			if (prop === "then") return;
+			const registerMethod = kind === "list" ? "listViews" : "editViews";
+			if (!hasRegistry) throw new Error(`No ${kind} views registered. Register them via .${registerMethod}() or use q.use(adminModule) defaults.`);
+			if (!registeredViewSet.has(prop)) {
+				const available = [...registeredViewSet].sort().join(", ");
+				throw new Error(`Unknown ${kind} view "${prop}". Register it via .${registerMethod}(). Available ${kind} views: ${available || "(none)"}`);
+			}
+			return (config = {}) => ({
+				view: prop,
+				...config
+			});
+		},
+		has: (_target, prop) => {
+			if (typeof prop !== "string") return false;
+			return hasRegistry && registeredViewSet.has(prop);
+		},
+		ownKeys: () => hasRegistry ? [...registeredViewSet] : [],
+		getOwnPropertyDescriptor: (_target, prop) => {
+			if (typeof prop !== "string") return;
+			if (hasRegistry && !registeredViewSet.has(prop)) return;
+			return {
+				configurable: true,
+				enumerable: hasRegistry,
+				writable: false,
+				value: (config = {}) => ({
+					view: prop,
+					...config
+				})
+			};
+		}
+	});
+}
+/**
+* Resolve registered view names from a builder's parent Questpie app state.
+*/
+function getRegisteredViewNames(builderState, kind) {
+	const views = getRegistrySourceState(builderState)[kind === "list" ? "listViews" : "editViews"];
+	if (!views || typeof views !== "object") return [];
+	return Object.keys(views);
+}
+/**
+* Validate a selected view name against registered view names.
+*/
+function ensureRegisteredView(kind, viewName, registeredViews) {
+	if (registeredViews.length === 0 || typeof viewName !== "string") return;
+	if (registeredViews.includes(viewName)) return;
+	const registerMethod = kind === "list" ? "listViews" : "editViews";
+	throw new Error(`Unknown ${kind} view "${viewName}". Register it via .${registerMethod}(). Available ${kind} views: ${registeredViews.sort().join(", ")}`);
+}
+/**
+* Create an action proxy for referencing built-in and custom actions.
+*
+* @example
+* ```ts
+* .list(({ a }) => ({
+*   actions: {
+*     header: { primary: [a.create] },
+*     bulk: [a.delete, a.export],
+*   },
+* }))
+* ```
+*/
+function createActionProxy() {
+	return {
+		create: "create",
+		save: "save",
+		delete: "delete",
+		deleteMany: "deleteMany",
+		duplicate: "duplicate",
+		export: "export",
+		custom: (name, config) => ({
+			type: name,
+			config
+		})
+	};
+}
+/**
+* Create action helpers for dashboard header actions.
+*/
+function createDashboardActionProxy() {
+	const toCollectionCreatePath = (collection) => `/admin/collections/${collection}/create`;
+	const toGlobalPath = (global) => `/admin/globals/${global}`;
+	return {
+		action: (config) => config,
+		link: (config) => config,
+		create: ({ collection, ...config }) => ({
+			...config,
+			href: toCollectionCreatePath(collection)
+		}),
+		global: ({ global, ...config }) => ({
+			...config,
+			href: toGlobalPath(global)
+		})
+	};
+}
+/**
+* Create an actions config context for the .actions() method.
+* Provides builders for both built-in and custom actions.
+*
+* @example
+* ```ts
+* .actions(({ a, c, f }) => ({
+*   builtin: [a.create(), a.delete(), a.deleteMany()],
+*   custom: [
+*     a.action({
+*       id: "send-email",
+*       label: { en: "Send Email" },
+*       icon: c.icon("ph:envelope"),
+*       form: {
+*         title: { en: "Send Email" },
+*         fields: {
+*           subject: f.text({ label: { en: "Subject" }, required: true }),
+*           message: f.textarea({ label: { en: "Message" } }),
+*         },
+*       },
+*       handler: async ({ data }) => {
+*         return { type: "success", toast: { message: "Email sent!" } };
+*       },
+*     }),
+*   ],
+* }))
+* ```
+*/
+function createActionsConfigContext(builderState, fieldRegistry) {
+	const fieldProxy = new Proxy({}, { get: (_target, prop) => {
+		const factory = fieldRegistry[prop];
+		if (!factory) {
+			const available = Object.keys(fieldRegistry).sort();
+			if (available.length === 0) throw new Error("No field types registered for action form fields. Register fields on the Questpie builder before using .actions().");
+			throw new Error(`Unknown field type: "${prop}". Available types: ${available.join(", ")}`);
+		}
+		return (config) => factory(config);
+	} });
+	return {
+		a: {
+			create: () => "create",
+			save: () => "save",
+			delete: () => "delete",
+			deleteMany: () => "deleteMany",
+			duplicate: () => "duplicate",
+			action: (def) => ({
+				...def,
+				scope: def.scope ?? "single"
+			}),
+			bulkAction: (def) => ({
+				...def,
+				scope: "bulk"
+			}),
+			headerAction: (def) => ({
+				...def,
+				scope: "header"
+			})
+		},
+		c: createComponentProxy(builderState),
+		f: fieldProxy
+	};
+}
+/**
+* Patch QuestpieBuilder with admin methods
+*/
+function patchQuestpieBuilder() {
+	const proto = QuestpieBuilder.prototype;
+	/**
+	* Create a list view definition.
+	* Returns a definition object for use in .listViews()
+	*/
+	proto.listView = (name, config = {}) => ({
+		type: "listView",
+		name,
+		...config
+	});
+	/**
+	* Create an edit view definition.
+	* Returns a definition object for use in .editViews()
+	*/
+	proto.editView = (name, config = {}) => ({
+		type: "editView",
+		name,
+		...config
+	});
+	/**
+	* Create a component definition.
+	* Returns a definition object for use in .components()
+	*/
+	proto.component = (name, config = {}) => ({
+		type: "component",
+		name,
+		...config
+	});
+	/**
+	* Register list views on the builder.
+	* Merges with existing list views.
+	*/
+	proto.listViews = function(views) {
+		return new QuestpieBuilder({
+			...this.state,
+			listViews: {
+				...this.state.listViews || {},
+				...views
+			}
+		});
+	};
+	/**
+	* Register edit views on the builder.
+	* Merges with existing edit views.
+	*/
+	proto.editViews = function(views) {
+		return new QuestpieBuilder({
+			...this.state,
+			editViews: {
+				...this.state.editViews || {},
+				...views
+			}
+		});
+	};
+	/**
+	* Register components on the builder.
+	* Merges with existing components.
+	*/
+	proto.components = function(components) {
+		return new QuestpieBuilder({
+			...this.state,
+			components: {
+				...this.state.components || {},
+				...components
+			}
+		});
+	};
+	/**
+	* Register block types for the visual block editor.
+	* Blocks are built and stored on the state for use by blocks fields.
+	*
+	* Accepts three input shapes per block:
+	* - **Server BlockBuilder** (legacy): `block("hero").fields(...).prefetch(...)`
+	* - **Client BlockDefinition**: `heroBlock` (auto-expansion handles relations)
+	* - **With manual prefetch**: `{ block: heroBlock, prefetch: async ({ values, ctx }) => ({...}) }`
+	*
+	* Relation and upload fields are auto-expanded in the afterRead hook.
+	* Use the `{ block, prefetch }` shape for custom data that can't be auto-expanded.
+	*
+	* @example
+	* ```ts
+	* import { heroBlock, textBlock } from "./blocks";
+	*
+	* const cms = q({ name: "my-app" })
+	*   .use(adminModule)
+	*   .blocks({
+	*     // Simple block - relations auto-expanded
+	*     hero: heroBlock,
+	*     text: textBlock,
+	*     // Block with manual prefetch for custom data
+	*     featuredPosts: {
+	*       block: featuredPostsBlock,
+	*       prefetch: async ({ values, ctx }) => {
+	*         const posts = await ctx.app.api.collections.posts.find({ limit: values.count });
+	*         return { posts: posts.docs };
+	*       },
+	*     },
+	*   })
+	*   .build({ ... });
+	* ```
+	*/
+	proto.blocks = function(blocks) {
+		const builtBlocks = {};
+		for (const [name, blockInput] of Object.entries(blocks)) {
+			if (typeof blockInput.build === "function" && typeof blockInput.state?.name === "string") {
+				const blockBuilder = blockInput;
+				const state = blockBuilder.state;
+				if (state._fieldsFactory && this.state.fields) {
+					const fieldProxy = createFieldBuilder(this.state.fields);
+					state.fields = state._fieldsFactory(fieldProxy);
+					delete state._fieldsFactory;
+				}
+				builtBlocks[name] = blockBuilder.build();
+				continue;
+			}
+			let blockDef;
+			let prefetchFn;
+			if ("block" in blockInput && typeof blockInput.block === "object" && blockInput.block !== null && "name" in blockInput.block) {
+				const wrapper = blockInput;
+				blockDef = wrapper.block;
+				prefetchFn = wrapper.prefetch;
+			} else blockDef = blockInput;
+			builtBlocks[name] = {
+				name: blockDef.name || name,
+				state: {
+					...blockDef.state,
+					prefetch: prefetchFn || blockDef.state.prefetch
+				},
+				getFieldMetadata: blockDef.getFieldMetadata.bind(blockDef),
+				executePrefetch: async (values, ctx) => {
+					if (prefetchFn) return prefetchFn({
+						values,
+						ctx
+					});
+					return blockDef.executePrefetch(values, ctx);
+				}
+			};
+		}
+		return new QuestpieBuilder({
+			...this.state,
+			blocks: {
+				...this.state.blocks || {},
+				...builtBlocks
+			}
+		});
+	};
+	/**
+	* Create a block builder bound to this Questpie builder.
+	* The block has access to all registered field types from `.fields()`.
+	*
+	* @example
+	* ```ts
+	* const qb = q.use(adminModule);
+	*
+	* const heroBlock = qb.block("hero")
+	*   .label({ en: "Hero Section" })
+	*   .icon("ph:image")
+	*   .fields((f) => ({
+	*     title: f.text({ required: true }),  // ✅ typed from builder's field registry
+	*     subtitle: f.text(),
+	*   }));
+	*
+	* const cms = qb
+	*   .blocks({ hero: heroBlock })
+	*   .build({ ... });
+	* ```
+	*/
+	proto.block = function(name) {
+		const registeredComponents = getRegisteredComponentNames(this.state);
+		return new BlockBuilder({
+			name,
+			"~components": registeredComponents
+		});
+	};
+	/**
+	* Configure the admin dashboard.
+	* Widgets that need data (stats, chart, recentItems) are executed on server.
+	*
+	* @example
+	* ```ts
+	* .dashboard(({ d, c, a }) => d.dashboard({
+	*   title: { en: "Dashboard" },
+	*   actions: [
+	*     a.create({
+	*       id: "new-user",
+	*       collection: "users",
+	*       label: { en: "New User" },
+	*       icon: c.icon("ph:user-plus"),
+	*     }),
+	*   ],
+	*   items: [
+	*     d.section({
+	*       label: { en: "Overview" },
+	*       items: [
+	*         d.stats({ collection: "users", label: { en: "Total Users" } }),
+	*       ],
+	*     }),
+	*   ],
+	* }))
+	* ```
+	*/
+	proto.dashboard = function(configFn) {
+		const dashboard = configFn({
+			a: createDashboardActionProxy(),
+			d: {
+				dashboard: (config) => config,
+				section: (config) => ({
+					type: "section",
+					...config
+				}),
+				tabs: (config) => ({
+					type: "tabs",
+					...config
+				}),
+				stats: (config) => ({
+					type: "stats",
+					...config
+				}),
+				chart: (config) => ({
+					type: "chart",
+					...config
+				}),
+				recentItems: (config) => ({
+					type: "recentItems",
+					...config
+				}),
+				quickActions: (config) => ({
+					type: "quickActions",
+					...config
+				}),
+				custom: (config) => ({
+					type: "custom",
+					...config
+				}),
+				value: (config) => ({
+					type: "value",
+					...config
+				}),
+				table: (config) => ({
+					type: "table",
+					...config
+				}),
+				timeline: (config) => ({
+					type: "timeline",
+					...config
+				}),
+				progress: (config) => ({
+					type: "progress",
+					...config
+				})
+			},
+			c: createComponentProxy(this.state)
+		});
+		return new QuestpieBuilder({
+			...this.state,
+			dashboard
+		});
+	};
+	/**
+	* Configure the admin sidebar.
+	* Sections can contain collections, globals, pages, links, and dividers.
+	*
+	* @example
+	* ```ts
+	* .sidebar(({ s, c }) => s.sidebar({
+	*   sections: [
+	*     s.section({
+	*       id: "content",
+	*       title: { en: "Content" },
+	*       icon: c.icon("ph:files"),
+	*       items: [
+	*         { type: "collection", collection: "posts" },
+	*         { type: "collection", collection: "pages" },
+	*       ],
+	*     }),
+	*   ],
+	* }))
+	* ```
+	*/
+	proto.sidebar = function(configFn) {
+		const sidebar = configFn({
+			s: {
+				sidebar: (config) => config,
+				section: (config) => ({
+					items: [],
+					...config
+				})
+			},
+			c: createComponentProxy(this.state)
+		});
+		return new QuestpieBuilder({
+			...this.state,
+			sidebar
+		});
+	};
+	proto.branding = function(config) {
+		return new QuestpieBuilder({
+			...this.state,
+			branding: config
+		});
+	};
+	/**
+	* Configure admin UI locales (separate from content locales).
+	*
+	* UI locales control the admin interface language.
+	* Content locales (set via .locale()) control which languages content can be edited in.
+	* These don't need to match - you can have 10 content languages but only 2 UI languages.
+	*
+	* @example
+	* ```ts
+	* const cms = q({ name: "my-app" })
+	*   .use(adminModule)
+	*   // Content can be in many languages
+	*   .locale({
+	*     locales: [{ code: "en" }, { code: "sk" }, { code: "de" }, ...],
+	*     defaultLocale: "en",
+	*   })
+	*   // But admin UI only in 2 languages
+	*   .adminLocale({
+	*     locales: ["en", "sk"],
+	*     defaultLocale: "en",
+	*   })
+	*   .build({ ... });
+	* ```
+	*/
+	proto.adminLocale = function(config) {
+		return new QuestpieBuilder({
+			...this.state,
+			adminLocale: config
+		});
+	};
+	/**
+	* Patch .use() to propagate admin extension properties.
+	*
+	* The core .use() only merges hardcoded properties (collections, globals,
+	* jobs, emailTemplates, fields, auth, locale, migrations, translations).
+	* Admin extensions (sidebar, dashboard, branding, listViews, editViews,
+	* components, blocks, adminLocale) would be lost without this patch.
+	*/
+	const originalUse = proto.use;
+	proto.use = function(other) {
+		const result = originalUse.call(this, other);
+		const otherState = other.state;
+		const coreKeys = new Set([
+			"name",
+			"collections",
+			"globals",
+			"jobs",
+			"emailTemplates",
+			"fields",
+			"auth",
+			"locale",
+			"migrations",
+			"translations",
+			"~messageKeys"
+		]);
+		const extensionState = {};
+		for (const key of Object.keys(this.state)) if (!coreKeys.has(key) && this.state[key] !== void 0) extensionState[key] = this.state[key];
+		for (const key of Object.keys(otherState)) if (!coreKeys.has(key) && otherState[key] !== void 0) extensionState[key] = otherState[key];
+		if (Object.keys(extensionState).length > 0) return new QuestpieBuilder({
+			...result.state,
+			...extensionState
+		});
+		return result;
+	};
+	/**
+	* Patch .build() to inject block definitions into blocks-type field configs
+	* before the real build, and to store admin extension state on the built
+	* Questpie instance so getAdminConfig can read sidebar/dashboard/etc.
+	*/
+	const originalBuild = proto.build;
+	proto.build = function(...args) {
+		const blockDefs = this.state.blocks;
+		if (blockDefs && Object.keys(blockDefs).length > 0) {
+			injectBlockDefinitions(this.state, blockDefs);
+			injectBlocksPrefetchHooks(this.state);
+			validateAllowedBlocks(this.state, blockDefs);
+		}
+		const instance = originalBuild.apply(this, args);
+		const extensionKeys = [
+			"sidebar",
+			"dashboard",
+			"branding",
+			"blocks",
+			"listViews",
+			"editViews",
+			"components",
+			"adminLocale"
+		];
+		const adminState = {};
+		for (const key of extensionKeys) if (this.state[key] !== void 0) adminState[key] = this.state[key];
+		instance.state = adminState;
+		return instance;
+	};
+}
+/**
+* Inject block definitions into all blocks-type field configs
+* in collections and globals. Enables per-block field validation.
+* @internal
+*/
+function injectBlockDefinitions(state, blockDefs) {
+	if (state.collections) for (const collection of Object.values(state.collections)) {
+		const fields = collection?.state?.fields;
+		if (!fields) continue;
+		for (const fieldDef of Object.values(fields)) if (fieldDef?.state?.config?.type === "blocks") fieldDef.state.config._blockDefinitions = blockDefs;
+	}
+	if (state.globals) for (const global of Object.values(state.globals)) {
+		const fields = global?.state?.fields;
+		if (!fields) continue;
+		for (const fieldDef of Object.values(fields)) if (fieldDef?.state?.config?.type === "blocks") fieldDef.state.config._blockDefinitions = blockDefs;
+	}
+}
+/**
+* Auto-inject afterRead hook for blocks prefetch on collections/globals
+* that have at least one blocks-type field.
+*
+* This eliminates the need for manually adding:
+* ```ts
+* .hooks({ afterRead: createBlocksPrefetchHook() })
+* ```
+* @internal
+*/
+function injectBlocksPrefetchHooks(state) {
+	const prefetchHook = createBlocksPrefetchHook();
+	const injectIfHasBlocksField = (entity, name) => {
+		const fieldDefinitions = entity?.state?.fieldDefinitions;
+		if (!fieldDefinitions) return;
+		if (!Object.values(fieldDefinitions).some((fieldDef) => fieldDef?.state?.type === "blocks")) return;
+		if (!entity.state.hooks) entity.state.hooks = {};
+		const existing = entity.state.hooks.afterRead;
+		if (!existing) entity.state.hooks.afterRead = prefetchHook;
+		else {
+			const existingArray = Array.isArray(existing) ? existing : [existing];
+			entity.state.hooks.afterRead = [...existingArray, prefetchHook];
+		}
+	};
+	if (state.collections) for (const [name, collection] of Object.entries(state.collections)) injectIfHasBlocksField(collection, name);
+	if (state.globals) for (const [name, global] of Object.entries(state.globals)) injectIfHasBlocksField(global, name);
+}
+/**
+* Validate that all `allowedBlocks` entries reference registered block types.
+* Logs warnings in development for unknown block types.
+* @internal
+*/
+function validateAllowedBlocks(state, blockDefs) {
+	const registeredNames = new Set(Object.keys(blockDefs));
+	const checkFields = (fields, context) => {
+		if (!fields) return;
+		for (const [fieldName, fieldDef] of Object.entries(fields)) {
+			const config = fieldDef?.state?.config;
+			if (config?.type === "blocks" && Array.isArray(config.allowedBlocks)) {
+				for (const blockType of config.allowedBlocks) if (!registeredNames.has(blockType)) console.warn(`[admin] Unknown block type "${blockType}" in allowedBlocks for field "${fieldName}" in ${context}. Registered block types: ${[...registeredNames].join(", ")}`);
+			}
+		}
+	};
+	if (state.collections) for (const [name, collection] of Object.entries(state.collections)) checkFields(collection?.state?.fields, `collection "${name}"`);
+	if (state.globals) for (const [name, global] of Object.entries(state.globals)) checkFields(global?.state?.fields, `global "${name}"`);
+}
+/**
+* Patch CollectionBuilder with admin methods
+*/
+function patchCollectionBuilder() {
+	const proto = CollectionBuilder.prototype;
+	/**
+	* Set admin metadata for the collection.
+	* Defines how the collection appears in the admin sidebar and UI.
+	*
+	* @example
+	* ```ts
+	* .admin(({ c }) => ({
+	*   label: { en: "Posts", sk: "Príspevky" },
+	*   icon: c.icon("ph:article"),
+	*   description: { en: "Blog posts and articles" },
+	* }))
+	* ```
+	*/
+	proto.admin = function(configOrFn) {
+		const config = typeof configOrFn === "function" ? configOrFn({ c: createComponentProxy(this.state) }) : configOrFn;
+		const newBuilder = new CollectionBuilder({
+			...this.state,
+			admin: config
+		});
+		if (this._indexesFn) newBuilder._indexesFn = this._indexesFn;
+		return newBuilder;
+	};
+	/**
+	* Configure list view for the collection.
+	* Defines columns, sorting, filtering, and actions for the list page.
+	*
+	* @example
+	* ```ts
+	* .list(({ v, f, a }) => v.table({
+	*   columns: [f.title, f.author, f.status, f.createdAt],
+	*   defaultSort: { field: "createdAt", direction: "desc" },
+	*   searchable: ["title", "content"],
+	*   filterable: ["status", "author"],
+	*   actions: {
+	*     header: { primary: [a.create] },
+	*     row: [a.duplicate, a.delete],
+	*     bulk: [a.delete],
+	*   },
+	* }))
+	* ```
+	*/
+	proto.list = function(configFn) {
+		const fieldNames = Object.keys(this.state.fields || {});
+		const registeredListViews = getRegisteredViewNames(this.state, "list");
+		const config = configFn({
+			v: createViewProxy("list", registeredListViews),
+			f: createFieldProxy(fieldNames),
+			a: createActionProxy()
+		});
+		ensureRegisteredView("list", config.view, registeredListViews);
+		const newBuilder = new CollectionBuilder({
+			...this.state,
+			adminList: config
+		});
+		if (this._indexesFn) newBuilder._indexesFn = this._indexesFn;
+		return newBuilder;
+	};
+	/**
+	* Configure form view for the collection.
+	* Defines field layout, sections, and tabs for create/edit pages.
+	*
+	* @example
+	* ```ts
+	* .form(({ v, f }) => v.form({
+	*   sections: [
+	*     {
+	*       label: { en: "Basic Info" },
+	*       fields: [f.title, f.slug, f.content],
+	*     },
+	*     {
+	*       label: { en: "Publishing" },
+	*       fields: [f.status, f.publishedAt, f.author],
+	*       collapsible: true,
+	*     },
+	*   ],
+	* }))
+	* ```
+	*/
+	proto.form = function(configFn) {
+		const fieldNames = Object.keys(this.state.fields || {});
+		const registeredEditViews = getRegisteredViewNames(this.state, "edit");
+		const config = configFn({
+			v: createViewProxy("edit", registeredEditViews),
+			f: createFieldProxy(fieldNames)
+		});
+		ensureRegisteredView("edit", config.view, registeredEditViews);
+		const newBuilder = new CollectionBuilder({
+			...this.state,
+			adminForm: config
+		});
+		if (this._indexesFn) newBuilder._indexesFn = this._indexesFn;
+		return newBuilder;
+	};
+	/**
+	* Configure preview for the collection.
+	* Enables live preview panel in the edit page.
+	*
+	* @example
+	* ```ts
+	* .preview({
+	*   enabled: true,
+	*   url: ({ record, locale }) => `/preview/posts/${record.slug}?locale=${locale}`,
+	*   position: "right",
+	*   defaultWidth: 50,
+	* })
+	* ```
+	*/
+	proto.preview = function(config) {
+		const newBuilder = new CollectionBuilder({
+			...this.state,
+			adminPreview: config
+		});
+		if (this._indexesFn) newBuilder._indexesFn = this._indexesFn;
+		return newBuilder;
+	};
+	/**
+	* Configure actions for the collection.
+	* Enables built-in actions (create, delete, etc.) and custom actions with forms.
+	*
+	* Form fields use the same field registry as collections. The field proxy `f`
+	* is resolved at build time when the full field registry is available.
+	*
+	* @example
+	* ```ts
+	* .actions(({ a, c, f }) => ({
+	*   builtin: [a.create(), a.delete(), a.deleteMany(), a.duplicate()],
+	*   custom: [
+	*     a.action({
+	*       id: "publish",
+	*       label: { en: "Publish" },
+	*       icon: c.icon("ph:check-circle"),
+	*       confirmation: {
+	*         title: { en: "Publish this item?" },
+	*         description: { en: "This will make the item visible to the public." },
+	*       },
+	*       handler: async ({ itemId, app, db }) => {
+	*         // publish logic
+	*         return { type: "success", toast: { message: "Published!" } };
+	*       },
+	*     }),
+	*     a.action({
+	*       id: "send-email",
+	*       label: { en: "Send Email" },
+	*       icon: c.icon("ph:envelope"),
+	*       form: {
+	*         title: { en: "Send Email" },
+	*         fields: {
+	*           subject: f.text({ label: { en: "Subject" }, required: true }),
+	*           message: f.textarea({ label: { en: "Message" } }),
+	*         },
+	*       },
+	*       handler: async ({ data }) => {
+	*         // send email logic - data.subject, data.message are typed
+	*         return { type: "success", toast: { message: "Email sent!" } };
+	*       },
+	*     }),
+	*     a.bulkAction({
+	*       id: "bulk-publish",
+	*       label: { en: "Publish Selected" },
+	*       handler: async ({ itemIds }) => {
+	*         // bulk publish logic
+	*         return { type: "success", toast: { message: `${itemIds?.length} items published!` } };
+	*       },
+	*     }),
+	*   ],
+	* }))
+	* ```
+	*/
+	proto.actions = function(configFn) {
+		const builderFields = this.state["~questpieApp"]?.state?.fields;
+		const fieldRegistry = {};
+		if (builderFields && Object.keys(builderFields).length > 0) for (const [name, fieldDef] of Object.entries(builderFields)) fieldRegistry[name] = (config$1) => createFieldDefinition(fieldDef, config$1);
+		const config = configFn(createActionsConfigContext(this.state, fieldRegistry));
+		const newBuilder = new CollectionBuilder({
+			...this.state,
+			adminActions: config
+		});
+		if (this._indexesFn) newBuilder._indexesFn = this._indexesFn;
+		return newBuilder;
+	};
+	/**
+	* Patch .merge() to propagate admin extension properties.
+	*
+	* The core .merge() only merges hardcoded collection properties (fields,
+	* indexes, hooks, access, etc.). Admin extensions (admin, adminList,
+	* adminForm, adminPreview, adminActions) would be lost without this patch.
+	*/
+	const originalMerge = proto.merge;
+	proto.merge = function(other) {
+		const result = originalMerge.call(this, other);
+		for (const key of [
+			"admin",
+			"adminList",
+			"adminForm",
+			"adminPreview",
+			"adminActions"
+		]) {
+			const thisVal = this.state[key];
+			const otherVal = other.state[key];
+			if (otherVal !== void 0) result.state[key] = otherVal;
+			else if (thisVal !== void 0) result.state[key] = thisVal;
+		}
+		return result;
+	};
+}
+/**
+* Patch GlobalBuilder with admin methods
+*/
+function patchGlobalBuilder() {
+	const proto = GlobalBuilder.prototype;
+	/**
+	* Set admin metadata for the global.
+	* Defines how the global appears in the admin sidebar and UI.
+	*
+	* @example
+	* ```ts
+	* .admin(({ c }) => ({
+	*   label: { en: "Site Settings", sk: "Nastavenia stránky" },
+	*   icon: c.icon("ph:gear"),
+	* }))
+	* ```
+	*/
+	proto.admin = function(configOrFn) {
+		const config = typeof configOrFn === "function" ? configOrFn({ c: createComponentProxy(this.state) }) : configOrFn;
+		return new GlobalBuilder({
+			...this.state,
+			admin: config
+		});
+	};
+	/**
+	* Configure form view for the global.
+	* Defines field layout, sections, and tabs for the settings page.
+	*
+	* @example
+	* ```ts
+	* .form(({ v, f }) => v.form({
+	*   tabs: [
+	*     {
+	*       label: { en: "General" },
+	*       icon: c.icon("ph:gear"),
+	*       sections: [
+	*         { fields: [f.siteName, f.siteDescription, f.logo] },
+	*       ],
+	*     },
+	*     {
+	*       label: { en: "Social Media" },
+	*       icon: c.icon("ph:share-network"),
+	*       sections: [
+	*         { fields: [f.socialLinks] },
+	*       ],
+	*     },
+	*   ],
+	* }))
+	* ```
+	*/
+	proto.form = function(configFn) {
+		const fieldNames = Object.keys(this.state.fields || {});
+		const registeredEditViews = getRegisteredViewNames(this.state, "edit");
+		const config = configFn({
+			v: createViewProxy("edit", registeredEditViews),
+			f: createFieldProxy(fieldNames)
+		});
+		ensureRegisteredView("edit", config.view, registeredEditViews);
+		return new GlobalBuilder({
+			...this.state,
+			adminForm: config
+		});
+	};
+}
+/**
+* Apply all admin patches to builder prototypes.
+* This function is idempotent - calling it multiple times has no effect.
+*
+* Called automatically when adminModule is used via .use()
+*/
+function applyAdminPatches() {
+	if (patchesApplied) return;
+	patchQuestpieBuilder();
+	patchCollectionBuilder();
+	patchGlobalBuilder();
+	patchesApplied = true;
+}
+/**
+* Check if admin patches have been applied.
+* Useful for debugging and testing.
+*/
+function arePatchesApplied() {
+	return patchesApplied;
+}
+applyAdminPatches();
+
+//#endregion
+export { applyAdminPatches, arePatchesApplied, createActionProxy, createComponentProxy, createFieldProxy, createViewProxy };
+//# sourceMappingURL=patch.mjs.map