@questpie/admin 2.0.0 → 3.0.0

package/dist/server/{block → modules/admin/block}/block-builder.d.mts

@@ -1,43 +1,47 @@
-import { AdminBlockConfig, AdminConfigContext } from "../augmentation.mjs";
-import { FieldBuilderProxy, FieldDefinition, FieldDefinitionState, FieldSchema, RegisteredApp } from "questpie";
+import { AdminBlockConfig, FieldLayoutItem } from "../../../augmentation/form-layout.mjs";
+import { AdminConfigContext } from "../../../augmentation/views.mjs";
+import "../../../augmentation.mjs";
+import { adminFields } from "../../../fields/index.mjs";
+import { AppContext, BuiltinFields, Field, FieldBuilderProxy, FieldSchema, FieldState } from "questpie";
 
-//#region src/server/block/block-builder.d.ts
+//#region src/server/modules/admin/block/block-builder.d.ts
 
+/**
+ * Combined field types available in block field definitions.
+ * Includes all built-in questpie fields plus admin-specific fields (richText, blocks).
+ */
+type AdminBlockFields = BuiltinFields & typeof adminFields;
 /**
  * Block prefetch context.
  * Provided to prefetch functions to fetch related data.
  *
- * When you register your app via `Register.app`, `ctx.app` is automatically typed.
- * For module-scoped typing, use `getApp<T>(ctx.app)`.
+ * Use `typedApp<App>(ctx.app)` for typed access.
  *
  * @example
  * ```ts
- * // questpie.gen.ts - register your app for automatic typing
- * declare module "questpie" {
- *   interface Register {
- *     app: typeof import("./cms").baseCms.$inferCms;
- *   }
- * }
- *
- * // blocks.ts - ctx.app is now typed
  * .prefetch(async ({ values, ctx }) => {
- *   const res = await ctx.app.api.collections.posts.find({ limit: 5 });
+ *   const app = typedApp<App>(ctx.app);
+ *   const res = await app.collections.posts.find({ limit: 5 });
  *   return { posts: res.docs };
  * })
  * ```
  */
-interface BlockPrefetchContext {
+type BlockPrefetchContext = AppContext & {
+  /** App instance — populated at runtime by extractAppServices */
+  app: unknown;
+  /** Database handle — populated at runtime by extractAppServices */
+  db: unknown;
+  /** Collection APIs — populated at runtime by extractAppServices */
+  collections: Record<string, any>;
+  /** Global APIs — populated at runtime by extractAppServices */
+  globals: Record<string, any>;
   /** Block instance ID */
   blockId: string;
   /** Block type name */
   blockType: string;
-  /** CMS app instance — typed via Register.app */
-  app: RegisteredApp;
   /** Current locale */
   locale?: string;
-  /** Database client */
-  db: unknown;
-}
+};
 /**
  * Block prefetch function.
  * Runs during CRUD read to fetch related data for the block.
@@ -93,7 +97,7 @@ type ExpandWithResult<TWith> = { [K in keyof TWith as TWith[K] extends false | u
 /**
  * Block builder state.
  */
-interface BlockBuilderState<TName extends string = string, TFields extends Record<string, FieldDefinition<FieldDefinitionState>> = Record<string, FieldDefinition<FieldDefinitionState>>> {
+interface BlockBuilderState<TName extends string = string, TFields extends Record<string, Field<FieldState>> = Record<string, Field<FieldState>>> {
   /** Block type name */
   name: TName;
   /** Admin configuration (label, icon, description, category, etc.) */
@@ -116,6 +120,10 @@ interface BlockBuilderState<TName extends string = string, TFields extends Recor
   }) => Promise<Record<string, unknown>> | Record<string, unknown>;
   /** Type-level marker for prefetch data type (not used at runtime) */
   "~prefetchData"?: unknown;
+  /** Form layout for block fields (sections, tabs, grid) */
+  form?: {
+    fields: FieldLayoutItem[];
+  };
   /** Optional registered component names from Questpie builder registry */
   "~components"?: string[];
 }
@@ -139,9 +147,28 @@ interface BlockDefinition<TState extends BlockBuilderState = BlockBuilderState>
  * @template TFieldMap - Field type map for typed field proxy (from builder's registered fields)
  * @template TData - Prefetch data type (set by .prefetch(), preserved through chain)
  */
-declare class BlockBuilder<TState extends BlockBuilderState = BlockBuilderState, TFieldMap extends Record<string, any> = Record<string, any>, TData = Record<string, unknown>> {
+declare class BlockBuilder<TState extends BlockBuilderState = BlockBuilderState, TFieldMap extends Record<string, any> = AdminBlockFields, TData = Record<string, unknown>> {
   private _state;
+  /**
+   * Runtime field factories map. When provided (by codegen-generated factories),
+   * includes both builtin fields AND module-contributed fields with extension
+   * methods (e.g. `.admin()`, `.form()`). Falls back to raw builtinFields +
+   * adminFields when not provided (direct BlockBuilder usage).
+   */
+  private _fieldDefs?;
   constructor(state: TState);
+  /**
+   * Create a new BlockBuilder with optional pre-wrapped field defs.
+   *
+   * Mirrors CollectionBuilder.create() — codegen-generated factory functions
+   * pass the merged+wrapped field map so that field extension methods
+   * (`.admin()`, `.form()`) are available inside `.fields()` callbacks.
+   */
+  static create<TName extends string, TFieldTypes extends Record<string, any> = AdminBlockFields>(name: TName, fieldDefs?: Record<string, any>): BlockBuilder<{
+    name: TName;
+  }, TFieldTypes>;
+  /** Create a child builder that inherits _fieldDefs. */
+  private _child;
   /**
    * Set admin metadata for the block.
    * Follows the same pattern as collection .admin() method.
@@ -170,18 +197,54 @@ declare class BlockBuilder<TState extends BlockBuilderState = BlockBuilderState,
    * Define fields for the block.
    * Uses the same field builder as collections.
    *
+   * Uses destructured context object syntax: `({ f }) =>` (not positional `(f) =>`).
+   * This is consistent with collection/global `.fields()` and allows future
+   * extension of the context without breaking changes.
+   *
    * @example
    * ```ts
-   * block("hero").fields((f) => ({
+   * block("hero").fields(({ f }) => ({
    *   title: f.text({ required: true }),
    *   subtitle: f.text(),
    *   image: f.upload({ accept: "image/*" }),
    * }))
    * ```
    */
-  fields<TNewFields extends Record<string, FieldDefinition<FieldDefinitionState>>>(factory: (f: FieldBuilderProxy<TFieldMap>) => TNewFields): BlockBuilder<Omit<TState, "fields"> & {
+  fields<TNewFields extends Record<string, Field<FieldState>>>(factory: (ctx: {
+    f: FieldBuilderProxy<TFieldMap>;
+  }) => TNewFields): BlockBuilder<Omit<TState, "fields"> & {
     fields: TNewFields;
   }, TFieldMap, TData>;
+  /**
+   * Define form layout for block fields.
+   * Supports sections, tabs, and grid layouts — same as collection .form().
+   *
+   * @example
+   * ```ts
+   * block("pricing")
+   *   .fields(({ f }) => ({
+   *     title: f.text().required(),
+   *     price: f.number().required(),
+   *     currency: f.select([...]),
+   *     description: f.textarea(),
+   *   }))
+   *   .form(({ f }) => ({
+   *     fields: [
+   *       { type: "section", label: "Basic", fields: [f.title, f.description] },
+   *       { type: "section", label: "Pricing", layout: "grid", fields: [f.price, f.currency] },
+   *     ],
+   *   }))
+   * ```
+   */
+  form(configFn: (ctx: {
+    f: Record<string, string>;
+  }) => {
+    fields: FieldLayoutItem[];
+  }): BlockBuilder<TState & {
+    form: {
+      fields: FieldLayoutItem[];
+    };
+  }, TFieldMap, TData>;
   /**
    * Allow child blocks (for layout blocks).
    *
@@ -272,15 +335,15 @@ declare class BlockBuilder<TState extends BlockBuilderState = BlockBuilderState,
  *       label: { en: "Layout" },
  *     },
  *   }))
- *   .fields((f) => ({
+ *   .fields(({ f }) => ({
  *     title: f.text({ required: true }),
  *     subtitle: f.text(),
  *   }));
  *
- * // Register blocks on CMS
- * const cms = q({ name: "my-app" })
- *   .use(adminModule)
- *   .blocks({ hero: heroBlock })
+ * // Register blocks on QUESTPIE
+ * const app = runtimeConfig({
+ *   modules: [adminModule],
+ *   blocks: { hero: heroBlock },
  *   .build({ ... });
  * ```
  */
@@ -292,7 +355,9 @@ declare function block<TName extends string>(name: TName): BlockBuilder<{
  * Infers value type per-field to produce heterogeneous types
  * (e.g., { title: string, count: number, showPrices: boolean }).
  */
-type InferBlockValues<TState extends BlockBuilderState> = TState["fields"] extends Record<string, FieldDefinition<FieldDefinitionState>> ? { [K in keyof TState["fields"]]: TState["fields"][K] extends FieldDefinition<infer TFieldState> ? TFieldState["value"] : unknown } : Record<string, unknown>;
+type InferBlockValues<TState extends BlockBuilderState> = TState["fields"] extends Record<string, any> ? { [K in keyof TState["fields"]]: TState["fields"][K] extends {
+  readonly _: infer TS extends FieldState;
+} ? TS["data"] : unknown } : Record<string, unknown>;
 /**
  * Extract prefetch data type from a block builder or block state.
  * Infers the `data` type based on `.prefetch()` configuration:
@@ -315,5 +380,4 @@ type AnyBlockBuilder = BlockBuilder<BlockBuilderState, any, any>;
  */
 type AnyBlockDefinition = BlockDefinition<BlockBuilderState>;
 //#endregion
-export { AnyBlockBuilder, AnyBlockDefinition, BlockBuilder, BlockBuilderState, BlockDefinition, BlockPrefetchContext, BlockPrefetchFn, BlockPrefetchWith, BlockPrefetchWithOptions, ExpandWithResult, ExpandedRecord, InferBlockData, InferBlockValues, block };
-//# sourceMappingURL=block-builder.d.mts.map
+export { AnyBlockBuilder, AnyBlockDefinition, BlockBuilder, BlockBuilderState, BlockDefinition, BlockPrefetchContext, BlockPrefetchFn, BlockPrefetchWith, BlockPrefetchWithOptions, ExpandWithResult, ExpandedRecord, InferBlockData, InferBlockValues, block };

package/dist/server/{block → modules/admin/block}/block-builder.mjs

@@ -1,4 +1,40 @@
-//#region src/server/block/block-builder.ts
+import { adminFields } from "../../../fields/index.mjs";
+import { builtinFields, createFieldNameProxy, createFieldsCallbackContext } from "questpie";
+
+//#region src/server/modules/admin/block/block-builder.ts
+/**
+* Block Builder
+*
+* Defines block types for the visual block editor.
+* Blocks are registered on the app builder and can be used in blocks fields.
+*
+* Each block has:
+* - Admin metadata (label, description, icon, category) via .admin()
+* - Fields (using the same field system as collections)
+* - Optional prefetch function (runs on CRUD read to fetch related data)
+* - Optional children configuration (for nested blocks)
+*
+* @example
+* ```ts
+* import { block } from "@questpie/admin/server";
+*
+* const heroBlock = block("hero")
+*   .admin(({ c }) => ({
+*     label: { en: "Hero Section", sk: "Hero sekcia" },
+*     icon: c.icon("ph:image"),
+*     category: {
+*       label: { en: "Sections", sk: "Sekcie" },
+*       icon: c.icon("ph:layout"),
+*     },
+*   }))
+*   .fields(({ f }) => ({
+*     title: f.text({ required: true }),
+*     subtitle: f.text(),
+*     backgroundImage: f.upload({ accept: "image/*" }),
+*   }))
+*   .prefetch({ with: { backgroundImage: true } });
+* ```
+*/
 /**
 * Create a component proxy for type-safe icon and UI element references.
 * Used in .admin() config functions.
@@ -65,10 +101,35 @@ function createComponentProxy(registeredComponentNames = []) {
 */
 var BlockBuilder = class BlockBuilder {
 	_state;
+	/**
+	* Runtime field factories map. When provided (by codegen-generated factories),
+	* includes both builtin fields AND module-contributed fields with extension
+	* methods (e.g. `.admin()`, `.form()`). Falls back to raw builtinFields +
+	* adminFields when not provided (direct BlockBuilder usage).
+	*/
+	_fieldDefs;
 	constructor(state) {
 		this._state = state;
 	}
 	/**
+	* Create a new BlockBuilder with optional pre-wrapped field defs.
+	*
+	* Mirrors CollectionBuilder.create() — codegen-generated factory functions
+	* pass the merged+wrapped field map so that field extension methods
+	* (`.admin()`, `.form()`) are available inside `.fields()` callbacks.
+	*/
+	static create(name, fieldDefs) {
+		const builder = new BlockBuilder({ name });
+		if (fieldDefs) builder._fieldDefs = fieldDefs;
+		return builder;
+	}
+	/** Create a child builder that inherits _fieldDefs. */
+	_child(state) {
+		const child = new BlockBuilder(state);
+		child._fieldDefs = this._fieldDefs;
+		return child;
+	}
+	/**
 	* Set admin metadata for the block.
 	* Follows the same pattern as collection .admin() method.
 	*
@@ -92,7 +153,7 @@ var BlockBuilder = class BlockBuilder {
 	admin(configOrFn) {
 		const registeredComponents = this._state["~components"] ?? [];
 		const config = typeof configOrFn === "function" ? configOrFn({ c: createComponentProxy(registeredComponents) }) : configOrFn;
-		return new BlockBuilder({
+		return this._child({
 			...this._state,
 			admin: config
 		});
@@ -101,9 +162,13 @@ var BlockBuilder = class BlockBuilder {
 	* Define fields for the block.
 	* Uses the same field builder as collections.
 	*
+	* Uses destructured context object syntax: `({ f }) =>` (not positional `(f) =>`).
+	* This is consistent with collection/global `.fields()` and allows future
+	* extension of the context without breaking changes.
+	*
 	* @example
 	* ```ts
-	* block("hero").fields((f) => ({
+	* block("hero").fields(({ f }) => ({
 	*   title: f.text({ required: true }),
 	*   subtitle: f.text(),
 	*   image: f.upload({ accept: "image/*" }),
@@ -111,9 +176,43 @@ var BlockBuilder = class BlockBuilder {
 	* ```
 	*/
 	fields(factory) {
-		return new BlockBuilder({
+		const resolvedFields = factory(createFieldsCallbackContext(this._fieldDefs ?? {
+			...builtinFields,
+			...adminFields
+		}));
+		const child = new BlockBuilder({
+			...this._state,
+			fields: resolvedFields
+		});
+		child._fieldDefs = this._fieldDefs;
+		return child;
+	}
+	/**
+	* Define form layout for block fields.
+	* Supports sections, tabs, and grid layouts — same as collection .form().
+	*
+	* @example
+	* ```ts
+	* block("pricing")
+	*   .fields(({ f }) => ({
+	*     title: f.text().required(),
+	*     price: f.number().required(),
+	*     currency: f.select([...]),
+	*     description: f.textarea(),
+	*   }))
+	*   .form(({ f }) => ({
+	*     fields: [
+	*       { type: "section", label: "Basic", fields: [f.title, f.description] },
+	*       { type: "section", label: "Pricing", layout: "grid", fields: [f.price, f.currency] },
+	*     ],
+	*   }))
+	* ```
+	*/
+	form(configFn) {
+		const resolved = configFn({ f: createFieldNameProxy() });
+		return this._child({
 			...this._state,
-			_fieldsFactory: factory
+			form: resolved
 		});
 	}
 	/**
@@ -126,19 +225,19 @@ var BlockBuilder = class BlockBuilder {
 	* ```
 	*/
 	allowChildren(maxChildren) {
-		return new BlockBuilder({
+		return this._child({
 			...this._state,
 			allowChildren: true,
 			maxChildren
 		});
 	}
 	prefetch(fnOrConfig) {
-		if (typeof fnOrConfig === "function") return new BlockBuilder({
+		if (typeof fnOrConfig === "function") return this._child({
 			...this._state,
 			prefetch: fnOrConfig
 		});
 		const { with: withFields, loader } = fnOrConfig;
-		return new BlockBuilder({
+		return this._child({
 			...this._state,
 			prefetchWith: withFields,
 			_prefetchLoader: loader
@@ -196,15 +295,15 @@ var BlockBuilder = class BlockBuilder {
 *       label: { en: "Layout" },
 *     },
 *   }))
-*   .fields((f) => ({
+*   .fields(({ f }) => ({
 *     title: f.text({ required: true }),
 *     subtitle: f.text(),
 *   }));
 *
-* // Register blocks on CMS
-* const cms = q({ name: "my-app" })
-*   .use(adminModule)
-*   .blocks({ hero: heroBlock })
+* // Register blocks on QUESTPIE
+* const app = runtimeConfig({
+*   modules: [adminModule],
+*   blocks: { hero: heroBlock },
 *   .build({ ... });
 * ```
 */
@@ -213,5 +312,4 @@ function block(name) {
 }
 
 //#endregion
-export { BlockBuilder, block };
-//# sourceMappingURL=block-builder.mjs.map
+export { BlockBuilder, block };

package/dist/server/modules/admin/block/index.d.mts

@@ -0,0 +1,3 @@
+import { AnyBlockBuilder, AnyBlockDefinition, BlockBuilder, BlockBuilderState, BlockDefinition, BlockPrefetchContext, BlockPrefetchFn, BlockPrefetchWith, BlockPrefetchWithOptions, ExpandWithResult, ExpandedRecord, InferBlockData, InferBlockValues, block } from "./block-builder.mjs";
+import { BlockSchema, getBlocksByCategory, introspectBlock, introspectBlocks } from "./introspection.mjs";
+import { BlocksPrefetchContext, createBlocksPrefetchHook, processBlocksDocument, processDocumentBlocksPrefetch } from "./prefetch.mjs";

package/dist/server/{block → modules/admin/block}/introspection.d.mts

@@ -1,9 +1,11 @@
+import { ComponentReference } from "../../../augmentation/common.mjs";
+import { BlockCategoryConfig, FieldLayoutItem } from "../../../augmentation/form-layout.mjs";
+import "../../../augmentation.mjs";
 import { AnyBlockDefinition } from "./block-builder.mjs";
-import { BlockCategoryConfig, ComponentReference } from "../augmentation.mjs";
 import { I18nText } from "questpie/shared";
 import { FieldSchema } from "questpie";
 
-//#region src/server/block/introspection.d.ts
+//#region src/server/modules/admin/block/introspection.d.ts
 
 /**
  * Introspected block schema for admin consumption.
@@ -35,6 +37,10 @@ interface BlockSchema {
   hasPrefetch: boolean;
   /** Field schemas - unified format using FieldSchema */
   fields: Record<string, FieldSchema>;
+  /** Form layout for block fields (sections, tabs, grid) */
+  form?: {
+    fields: FieldLayoutItem[];
+  };
   /** Validation schemas */
   validation?: {
     insert?: unknown;
@@ -69,7 +75,7 @@ declare function introspectBlock(blockDef: AnyBlockDefinition): BlockSchema;
  * import { introspectBlocks } from "@questpie/admin/server";
  *
  * // In an API route
- * const blocks = introspectBlocks(cms.state.blocks);
+ * const blocks = introspectBlocks(app.state.blocks);
  * return Response.json({ blocks });
  * ```
  */
@@ -80,5 +86,4 @@ declare function introspectBlocks(blocks: Record<string, AnyBlockDefinition> | u
  */
 declare function getBlocksByCategory(blocks: Record<string, BlockSchema>): CategoryInfo[];
 //#endregion
-export { BlockSchema, getBlocksByCategory, introspectBlock, introspectBlocks };
-//# sourceMappingURL=introspection.d.mts.map
+export { BlockSchema, getBlocksByCategory, introspectBlock, introspectBlocks };

package/dist/server/{block → modules/admin/block}/introspection.mjs

@@ -1,20 +1,32 @@
 import { isI18nLocaleMap } from "questpie/shared";
 
-//#region src/server/block/introspection.ts
+//#region src/server/modules/admin/block/introspection.ts
+/**
+* Normalize a block entry to a BlockDefinition.
+* App state may contain either built BlockDefinition objects (with getFieldMetadata)
+* or raw BlockBuilder instances (with a .build() method). This normalizes both
+* to a BlockDefinition by calling .build() on builders.
+*/
+function normalizeBlockDef(blockDef) {
+	if (typeof blockDef?.build === "function" && !blockDef.getFieldMetadata) return blockDef.build();
+	return blockDef;
+}
 /**
 * Introspect a single block definition.
 * Handles both server BlockBuilder definitions and client BlockDefinition objects
 * that were converted via the `.blocks()` patch.
 */
 function introspectBlock(blockDef) {
-	const state = blockDef.state;
+	const resolved = normalizeBlockDef(blockDef);
+	const state = resolved.state;
 	return {
-		name: state.name ?? blockDef.name,
+		name: state.name ?? resolved.name,
 		admin: state.admin,
 		allowChildren: state.allowChildren,
 		maxChildren: state.maxChildren,
 		hasPrefetch: typeof state.prefetch === "function",
-		fields: blockDef.getFieldMetadata()
+		fields: resolved.getFieldMetadata(),
+		form: state.form
 	};
 }
 /**
@@ -28,7 +40,7 @@ function introspectBlock(blockDef) {
 * import { introspectBlocks } from "@questpie/admin/server";
 *
 * // In an API route
-* const blocks = introspectBlocks(cms.state.blocks);
+* const blocks = introspectBlocks(app.state.blocks);
 * return Response.json({ blocks });
 * ```
 */
@@ -85,5 +97,4 @@ function getBlocksByCategory(blocks) {
 }
 
 //#endregion
-export { getBlocksByCategory, introspectBlock, introspectBlocks };
-//# sourceMappingURL=introspection.mjs.map
+export { getBlocksByCategory, introspectBlock, introspectBlocks };

package/dist/server/{block → modules/admin/block}/prefetch.d.mts

@@ -1,16 +1,15 @@
+import { BlocksDocument } from "../../../fields/blocks.mjs";
 import { AnyBlockDefinition } from "./block-builder.mjs";
-import { BlocksDocument } from "../fields/blocks.mjs";
-import { RegisteredApp } from "questpie";
 
-//#region src/server/block/prefetch.d.ts
+//#region src/server/modules/admin/block/prefetch.d.ts
 
 /**
  * Context for blocks prefetch processing.
- * Typed via Register.app when registered.
+ * Use `typedApp<App>(ctx.app)` for typed access.
  */
 interface BlocksPrefetchContext {
-  /** CMS app instance — typed via Register.app */
-  app: RegisteredApp;
+  /** app instance — use `typedApp<App>(ctx.app)` for typed access */
+  app: any;
   /** Database client */
   db: unknown;
   /** Current locale */
@@ -43,10 +42,9 @@ declare function processBlocksDocument(blocks: BlocksDocument | null | undefined
  * @returns The document with blocks prefetch data attached
  */
 declare function processDocumentBlocksPrefetch<T extends Record<string, unknown>>(doc: T, fieldDefinitions: Record<string, {
-  state: {
-    config: {
-      type?: string;
-    };
+  _state: {
+    customType?: string;
+    type: string;
   };
 }>, blockDefinitions: Record<string, AnyBlockDefinition>, ctx: BlocksPrefetchContext): Promise<T>;
 /**
@@ -55,16 +53,19 @@ declare function processDocumentBlocksPrefetch<T extends Record<string, unknown>
  *
  * @example
  * ```ts
+ * // collections/pages/index.ts
+ * import { collection } from "questpie";
  * import { createBlocksPrefetchHook } from "@questpie/admin/server";
  *
- * const pages = q.collection("pages")
- *   .fields((f) => ({
+ * export default collection("pages", {
+ *   fields: ({ f }) => ({
  *     title: f.text({ required: true }),
  *     content: f.blocks({ allowedBlocks: ["hero", "text"] }),
- *   }))
- *   .hooks({
+ *   }),
+ *   hooks: {
  *     afterRead: createBlocksPrefetchHook(),
- *   });
+ *   },
+ * });
  * ```
  */
 declare function createBlocksPrefetchHook(): (ctx: {
@@ -74,5 +75,4 @@ declare function createBlocksPrefetchHook(): (ctx: {
   locale?: string;
 }) => Promise<void>;
 //#endregion
-export { BlocksPrefetchContext, createBlocksPrefetchHook, processBlocksDocument, processDocumentBlocksPrefetch };
-//# sourceMappingURL=prefetch.d.mts.map
+export { BlocksPrefetchContext, createBlocksPrefetchHook, processBlocksDocument, processDocumentBlocksPrefetch };

package/dist/server/{block → modules/admin/block}/prefetch.mjs

@@ -1,4 +1,4 @@
-//#region src/server/block/prefetch.ts
+//#region src/server/modules/admin/block/prefetch.ts
 /**
 * Expand relation/upload fields declared in `prefetchWith`.
 *
@@ -55,12 +55,12 @@ async function expandDeclaredFields(allNodes, values, blockDefinitions, ctx) {
 	const fetchPromises = [...expansionsByCollection.entries()].map(async ([groupKey, { ids, nestedWith }]) => {
 		const collection = groupKey.includes(":") ? groupKey.slice(0, groupKey.indexOf(":")) : groupKey;
 		try {
-			const appApi = ctx.app?.api?.collections?.[collection];
-			if (!appApi?.find) {
-				console.warn(`[prefetch] Collection "${collection}" not found on app API, skipping`);
+			const collectionApi = ctx.app?.collections?.[collection];
+			if (!collectionApi?.find) {
+				console.warn(`[prefetch] Collection "${collection}" not found on app.collections, skipping`);
 				return;
 			}
-			const result = await appApi.find({
+			const result = await collectionApi.find({
 				where: { id: { in: [...ids] } },
 				limit: ids.size,
 				...nestedWith ? { with: nestedWith } : {}
@@ -79,7 +79,7 @@ async function expandDeclaredFields(allNodes, values, blockDefinitions, ctx) {
 		if (!recordMap) continue;
 		for (const { blockId, fieldName, isSingle } of targets) {
 			if (!expandedData[blockId]) expandedData[blockId] = {};
-			const blockVal = (values[blockId] || {})[fieldName];
+			const blockVal = values[blockId]?.[fieldName];
 			if (isSingle) expandedData[blockId][fieldName] = recordMap.get(blockVal) ?? null;
 			else {
 				const ids = blockVal;
@@ -148,8 +148,7 @@ async function executePrefetchFunctions(allNodes, values, blockDefinitions, ctx,
 		const prefetchCtx = {
 			blockId: node.id,
 			blockType: node.type,
-			app: ctx.app,
-			db: ctx.db,
+			...ctx,
 			locale: ctx.locale
 		};
 		const loader = blockDef.state._prefetchLoader;
@@ -194,7 +193,7 @@ async function executePrefetchFunctions(allNodes, values, blockDefinitions, ctx,
 async function processDocumentBlocksPrefetch(doc, fieldDefinitions, blockDefinitions, ctx) {
 	if (!doc || !blockDefinitions || Object.keys(blockDefinitions).length === 0) return doc;
 	const result = { ...doc };
-	for (const [fieldName, fieldDef] of Object.entries(fieldDefinitions)) if (fieldDef?.state?.config?.type === "blocks" && result[fieldName]) result[fieldName] = await processBlocksDocument(result[fieldName], blockDefinitions, ctx);
+	for (const [fieldName, fieldDef] of Object.entries(fieldDefinitions)) if ((fieldDef?._state?.customType ?? fieldDef?._state?.type) === "blocks" && result[fieldName]) result[fieldName] = await processBlocksDocument(result[fieldName], blockDefinitions, ctx);
 	return result;
 }
 /**
@@ -203,16 +202,19 @@ async function processDocumentBlocksPrefetch(doc, fieldDefinitions, blockDefinit
 *
 * @example
 * ```ts
+* // collections/pages/index.ts
+* import { collection } from "questpie";
 * import { createBlocksPrefetchHook } from "@questpie/admin/server";
 *
-* const pages = q.collection("pages")
-*   .fields((f) => ({
+* export default collection("pages", {
+*   fields: ({ f }) => ({
 *     title: f.text({ required: true }),
 *     content: f.blocks({ allowedBlocks: ["hero", "text"] }),
-*   }))
-*   .hooks({
+*   }),
+*   hooks: {
 *     afterRead: createBlocksPrefetchHook(),
-*   });
+*   },
+* });
 * ```
 */
 function createBlocksPrefetchHook() {
@@ -236,5 +238,4 @@ function isBlocksDocument(value) {
 }
 
 //#endregion
-export { createBlocksPrefetchHook, processBlocksDocument, processDocumentBlocksPrefetch };
-//# sourceMappingURL=prefetch.mjs.map
+export { createBlocksPrefetchHook, processBlocksDocument, processDocumentBlocksPrefetch };