@btst/stack 1.5.0 → 1.5.2

package/dist/plugins/cms/query-keys.d.mts

@@ -1,11 +1,8 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { createApiClient } from '@btst/stack/plugins/client';
-import { S as SerializedContentType, P as PaginatedContentItems, a as SerializedContentItemWithType } from '../../shared/stack.DBqxCs0V.mjs';
+import { S as SerializedContentType, P as PaginatedContentItems, a as SerializedContentItemWithType } from '../../shared/stack.L-UFwz2G.mjs';
 import { CMSApiRouter } from './api/index.mjs';
 import 'zod';
-import '../../shared/stack.NZJogTUn.mjs';
-import 'react-hook-form';
-import 'react/jsx-runtime';
 import '@btst/stack/plugins/api';
 import 'better-call';
 

package/dist/plugins/cms/query-keys.d.ts

@@ -1,11 +1,8 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { createApiClient } from '@btst/stack/plugins/client';
-import { S as SerializedContentType, P as PaginatedContentItems, a as SerializedContentItemWithType } from '../../shared/stack.DwnJA87a.js';
+import { S as SerializedContentType, P as PaginatedContentItems, a as SerializedContentItemWithType } from '../../shared/stack.L-UFwz2G.js';
 import { CMSApiRouter } from './api/index.js';
 import 'zod';
-import '../../shared/stack.NZJogTUn.js';
-import 'react-hook-form';
-import 'react/jsx-runtime';
 import '@btst/stack/plugins/api';
 import 'better-call';
 

package/dist/shared/{stack.DwnJA87a.d.ts → stack.L-UFwz2G.d.cts}

@@ -1,8 +1,16 @@
 import { z } from 'zod';
-import { A as AutoFormFieldType } from './stack.NZJogTUn.js';
 
 /**
- * Configuration for a content type defined by the developer
+ * Configuration for a content type defined by the developer.
+ *
+ * Field types are now specified directly in the Zod schema via .meta():
+ * @example
+ * ```typescript
+ * const ProductSchema = z.object({
+ *   description: z.string().meta({ fieldType: "textarea" }),
+ *   image: z.string().optional().meta({ fieldType: "file" }),
+ * });
+ * ```
  */
 interface ContentTypeConfig {
     /** Display name for the content type (e.g., "Product", "Testimonial") */
@@ -11,18 +19,8 @@ interface ContentTypeConfig {
     slug: string;
     /** Optional description shown in the admin UI */
     description?: string;
-    /** Zod schema defining the content type's fields */
+    /** Zod schema defining the content type's fields. Use .meta({ fieldType: "..." }) for field type overrides. */
     schema: z.ZodObject<z.ZodRawShape>;
-    /**
-     * Optional field configuration for AutoForm customization.
-     *
-     * fieldType can be:
-     * - A built-in AutoForm type: "checkbox", "date", "select", "radio", "switch", "textarea", "number", "file", "fallback"
-     * - A custom type name that maps to a component provided via `fieldComponents` in overrides
-     */
-    fieldConfig?: Record<string, {
-        fieldType?: AutoFormFieldType | (string & {});
-    }>;
 }
 /**
  * Content type stored in the database
@@ -37,8 +35,10 @@ type ContentType = {
     description?: string;
     /** JSON Schema representation of the Zod schema (stringified) */
     jsonSchema: string;
-    /** Optional field configuration JSON (stringified) */
+    /** @deprecated Legacy field config - now embedded in jsonSchema. Kept for backwards compat. */
     fieldConfig?: string;
+    /** AutoForm schema version. 1 = legacy (separate fieldConfig), 2 = unified (fieldType in jsonSchema) */
+    autoFormVersion?: number;
     createdAt: Date;
     updatedAt: Date;
 };

package/dist/shared/{stack.BwkyFwF8.d.cts → stack.L-UFwz2G.d.mts}

@@ -1,8 +1,16 @@
 import { z } from 'zod';
-import { A as AutoFormFieldType } from './stack.NZJogTUn.cjs';
 
 /**
- * Configuration for a content type defined by the developer
+ * Configuration for a content type defined by the developer.
+ *
+ * Field types are now specified directly in the Zod schema via .meta():
+ * @example
+ * ```typescript
+ * const ProductSchema = z.object({
+ *   description: z.string().meta({ fieldType: "textarea" }),
+ *   image: z.string().optional().meta({ fieldType: "file" }),
+ * });
+ * ```
  */
 interface ContentTypeConfig {
     /** Display name for the content type (e.g., "Product", "Testimonial") */
@@ -11,18 +19,8 @@ interface ContentTypeConfig {
     slug: string;
     /** Optional description shown in the admin UI */
     description?: string;
-    /** Zod schema defining the content type's fields */
+    /** Zod schema defining the content type's fields. Use .meta({ fieldType: "..." }) for field type overrides. */
     schema: z.ZodObject<z.ZodRawShape>;
-    /**
-     * Optional field configuration for AutoForm customization.
-     *
-     * fieldType can be:
-     * - A built-in AutoForm type: "checkbox", "date", "select", "radio", "switch", "textarea", "number", "file", "fallback"
-     * - A custom type name that maps to a component provided via `fieldComponents` in overrides
-     */
-    fieldConfig?: Record<string, {
-        fieldType?: AutoFormFieldType | (string & {});
-    }>;
 }
 /**
  * Content type stored in the database
@@ -37,8 +35,10 @@ type ContentType = {
     description?: string;
     /** JSON Schema representation of the Zod schema (stringified) */
     jsonSchema: string;
-    /** Optional field configuration JSON (stringified) */
+    /** @deprecated Legacy field config - now embedded in jsonSchema. Kept for backwards compat. */
     fieldConfig?: string;
+    /** AutoForm schema version. 1 = legacy (separate fieldConfig), 2 = unified (fieldType in jsonSchema) */
+    autoFormVersion?: number;
     createdAt: Date;
     updatedAt: Date;
 };

package/dist/shared/{stack.DBqxCs0V.d.mts → stack.L-UFwz2G.d.ts}

@@ -1,8 +1,16 @@
 import { z } from 'zod';
-import { A as AutoFormFieldType } from './stack.NZJogTUn.mjs';
 
 /**
- * Configuration for a content type defined by the developer
+ * Configuration for a content type defined by the developer.
+ *
+ * Field types are now specified directly in the Zod schema via .meta():
+ * @example
+ * ```typescript
+ * const ProductSchema = z.object({
+ *   description: z.string().meta({ fieldType: "textarea" }),
+ *   image: z.string().optional().meta({ fieldType: "file" }),
+ * });
+ * ```
  */
 interface ContentTypeConfig {
     /** Display name for the content type (e.g., "Product", "Testimonial") */
@@ -11,18 +19,8 @@ interface ContentTypeConfig {
     slug: string;
     /** Optional description shown in the admin UI */
     description?: string;
-    /** Zod schema defining the content type's fields */
+    /** Zod schema defining the content type's fields. Use .meta({ fieldType: "..." }) for field type overrides. */
     schema: z.ZodObject<z.ZodRawShape>;
-    /**
-     * Optional field configuration for AutoForm customization.
-     *
-     * fieldType can be:
-     * - A built-in AutoForm type: "checkbox", "date", "select", "radio", "switch", "textarea", "number", "file", "fallback"
-     * - A custom type name that maps to a component provided via `fieldComponents` in overrides
-     */
-    fieldConfig?: Record<string, {
-        fieldType?: AutoFormFieldType | (string & {});
-    }>;
 }
 /**
  * Content type stored in the database
@@ -37,8 +35,10 @@ type ContentType = {
     description?: string;
     /** JSON Schema representation of the Zod schema (stringified) */
     jsonSchema: string;
-    /** Optional field configuration JSON (stringified) */
+    /** @deprecated Legacy field config - now embedded in jsonSchema. Kept for backwards compat. */
     fieldConfig?: string;
+    /** AutoForm schema version. 1 = legacy (separate fieldConfig), 2 = unified (fieldType in jsonSchema) */
+    autoFormVersion?: number;
     createdAt: Date;
     updatedAt: Date;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btst/stack",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "A composable, plugin-based library for building full-stack applications.",
   "repository": {
     "type": "git",

package/src/plugins/blog/client/components/pages/edit-post-page.internal.tsx

@@ -6,18 +6,18 @@ import { PageHeader } from "../shared/page-header";
 import { PageWrapper } from "../shared/page-wrapper";
 import { BLOG_LOCALIZATION } from "../../localization";
 import type { BlogPluginOverrides } from "../../overrides";
-import { useRouteLifecycle } from "../shared/use-route-lifecycle";
+import { useRouteLifecycle } from "@workspace/ui/hooks/use-route-lifecycle";
 
 // Internal component with actual page content
 export function EditPostPage({ slug }: { slug: string }) {
-	const { localization } = usePluginOverrides<
+	const overrides = usePluginOverrides<
 		BlogPluginOverrides,
 		Partial<BlogPluginOverrides>
 	>("blog", {
 		localization: BLOG_LOCALIZATION,
 	});
+	const { localization, navigate } = overrides;
 	const basePath = useBasePath();
-	const { navigate } = usePluginOverrides<BlogPluginOverrides>("blog");
 
 	// Call lifecycle hooks
 	useRouteLifecycle({
@@ -27,6 +27,7 @@ export function EditPostPage({ slug }: { slug: string }) {
 			params: { slug },
 			isSSR: typeof window === "undefined",
 		},
+		overrides,
 		beforeRenderHook: (overrides, context) => {
 			if (overrides.onBeforeEditPostPageRendered) {
 				return overrides.onBeforeEditPostPageRendered(slug, context);

package/src/plugins/blog/client/components/pages/home-page.internal.tsx

@@ -9,16 +9,17 @@ import { useSuspensePosts } from "../../hooks/blog-hooks";
 import { BLOG_LOCALIZATION } from "../../localization";
 import { usePluginOverrides } from "@btst/stack/context";
 import type { BlogPluginOverrides } from "../../overrides";
-import { useRouteLifecycle } from "../shared/use-route-lifecycle";
+import { useRouteLifecycle } from "@workspace/ui/hooks/use-route-lifecycle";
 
 // Internal component with actual page content
 export function HomePage({ published }: { published: boolean }) {
-	const { localization } = usePluginOverrides<
+	const overrides = usePluginOverrides<
 		BlogPluginOverrides,
 		Partial<BlogPluginOverrides>
 	>("blog", {
 		localization: BLOG_LOCALIZATION,
 	});
+	const { localization } = overrides;
 
 	// Call lifecycle hooks
 	useRouteLifecycle({
@@ -28,6 +29,7 @@ export function HomePage({ published }: { published: boolean }) {
 			isSSR: typeof window === "undefined",
 			published,
 		},
+		overrides,
 		beforeRenderHook: (overrides, context) => {
 			if (published && overrides.onBeforePostsPageRendered) {
 				return overrides.onBeforePostsPageRendered(context);

package/src/plugins/blog/client/components/pages/new-post-page.internal.tsx

@@ -6,17 +6,17 @@ import { PageHeader } from "../shared/page-header";
 import { PageWrapper } from "../shared/page-wrapper";
 import type { BlogPluginOverrides } from "../../overrides";
 import { BLOG_LOCALIZATION } from "../../localization";
-import { useRouteLifecycle } from "../shared/use-route-lifecycle";
+import { useRouteLifecycle } from "@workspace/ui/hooks/use-route-lifecycle";
 
 // Internal component with actual page content
 export function NewPostPage() {
-	const { localization } = usePluginOverrides<
+	const overrides = usePluginOverrides<
 		BlogPluginOverrides,
 		Partial<BlogPluginOverrides>
 	>("blog", {
 		localization: BLOG_LOCALIZATION,
 	});
-	const { navigate } = usePluginOverrides<BlogPluginOverrides>("blog");
+	const { localization, navigate } = overrides;
 	const basePath = useBasePath();
 
 	// Call lifecycle hooks
@@ -26,6 +26,7 @@ export function NewPostPage() {
 			path: "/blog/new",
 			isSSR: typeof window === "undefined",
 		},
+		overrides,
 		beforeRenderHook: (overrides, context) => {
 			if (overrides.onBeforeNewPostPageRendered) {
 				return overrides.onBeforeNewPostPageRendered(context);

package/src/plugins/blog/client/components/pages/post-page.internal.tsx

@@ -17,19 +17,20 @@ import { BLOG_LOCALIZATION } from "../../localization";
 import { PostNavigation } from "../shared/post-navigation";
 import { RecentPostsCarousel } from "../shared/recent-posts-carousel";
 import { Badge } from "@workspace/ui/components/badge";
-import { useRouteLifecycle } from "../shared/use-route-lifecycle";
+import { useRouteLifecycle } from "@workspace/ui/hooks/use-route-lifecycle";
 import { OnThisPage, OnThisPageSelect } from "../shared/on-this-page";
 import type { SerializedPost } from "../../../types";
 
 // Internal component with actual page content
 export function PostPage({ slug }: { slug: string }) {
-	const { Image, localization } = usePluginOverrides<
+	const overrides = usePluginOverrides<
 		BlogPluginOverrides,
 		Partial<BlogPluginOverrides>
 	>("blog", {
 		Image: DefaultImage,
 		localization: BLOG_LOCALIZATION,
 	});
+	const { Image, localization } = overrides;
 
 	// Call lifecycle hooks
 	useRouteLifecycle({
@@ -39,6 +40,7 @@ export function PostPage({ slug }: { slug: string }) {
 			params: { slug },
 			isSSR: typeof window === "undefined",
 		},
+		overrides,
 		beforeRenderHook: (overrides, context) => {
 			if (overrides.onBeforePostPageRendered) {
 				return overrides.onBeforePostPageRendered(slug, context);

package/src/plugins/blog/client/components/pages/tag-page.internal.tsx

@@ -10,16 +10,17 @@ import { BLOG_LOCALIZATION } from "../../localization";
 import { usePluginOverrides } from "@btst/stack/context";
 import type { BlogPluginOverrides } from "../../overrides";
 import { useTags } from "../../hooks/blog-hooks";
-import { useRouteLifecycle } from "../shared/use-route-lifecycle";
+import { useRouteLifecycle } from "@workspace/ui/hooks/use-route-lifecycle";
 
 // Internal component with actual page content
 export function TagPage({ tagSlug }: { tagSlug: string }) {
-	const { localization } = usePluginOverrides<
+	const overrides = usePluginOverrides<
 		BlogPluginOverrides,
 		Partial<BlogPluginOverrides>
 	>("blog", {
 		localization: BLOG_LOCALIZATION,
 	});
+	const { localization } = overrides;
 
 	// Call lifecycle hooks
 	useRouteLifecycle({
@@ -29,6 +30,7 @@ export function TagPage({ tagSlug }: { tagSlug: string }) {
 			params: { tagSlug },
 			isSSR: typeof window === "undefined",
 		},
+		overrides,
 	});
 
 	const { tags } = useTags();

package/src/plugins/blog/client/plugin.tsx

@@ -386,15 +386,16 @@ function createTagLoader(tagSlug: string, config: BlogClientConfig) {
 				const tagsQuery = queries.tags.list();
 				await queryClient.prefetchQuery(tagsQuery);
 
-				if (hooks?.onLoadError) {
-					const queryState = queryClient.getQueryState(listQuery.queryKey);
-					if (queryState?.error) {
-						const error =
-							queryState.error instanceof Error
-								? queryState.error
-								: new Error(String(queryState.error));
-						await hooks.onLoadError(error, context);
-					}
+				// Check if there was an error in either query
+				const listState = queryClient.getQueryState(listQuery.queryKey);
+				const tagsState = queryClient.getQueryState(tagsQuery.queryKey);
+				const queryError = listState?.error || tagsState?.error;
+				if (queryError && hooks?.onLoadError) {
+					const error =
+						queryError instanceof Error
+							? queryError
+							: new Error(String(queryError));
+					await hooks.onLoadError(error, context);
 				}
 			} catch (error) {
 				if (hooks?.onLoadError) {

package/src/plugins/cms/__tests__/schema-roundtrip.test.ts

@@ -338,6 +338,201 @@ describe("Zod to JSON Schema roundtrip", () => {
 		});
 	});
 
+	describe("Unified schema format with fieldType in .meta()", () => {
+		it("preserves fieldType in JSON Schema properties", () => {
+			const schema = z.object({
+				description: z.string().meta({
+					description: "Full description",
+					fieldType: "textarea",
+				}),
+				image: z.string().optional().meta({
+					description: "Image URL",
+					fieldType: "file",
+				}),
+			});
+
+			const jsonSchema = z.toJSONSchema(schema) as {
+				properties?: Record<
+					string,
+					{ description?: string; fieldType?: string }
+				>;
+			};
+
+			// fieldType should be preserved in JSON Schema properties
+			expect(jsonSchema.properties?.description?.fieldType).toBe("textarea");
+			expect(jsonSchema.properties?.image?.fieldType).toBe("file");
+		});
+
+		it("preserves placeholder in JSON Schema properties", () => {
+			const schema = z.object({
+				name: z.string().meta({
+					placeholder: "Enter product name...",
+				}),
+			});
+
+			const jsonSchema = z.toJSONSchema(schema) as {
+				properties?: Record<string, { placeholder?: string }>;
+			};
+
+			expect(jsonSchema.properties?.name?.placeholder).toBe(
+				"Enter product name...",
+			);
+		});
+
+		it("simulates unified schema storage and retrieval", () => {
+			// This test simulates the new CMS flow with unified schema:
+			// 1. Developer defines schema with fieldType in .meta()
+			// 2. Backend converts to JSON Schema and stores (fieldType embedded)
+			// 3. Client reads JSON Schema and extracts fieldType for AutoForm
+
+			// Step 1: Developer defines schema with fieldType in .meta()
+			const ProductSchema = z.object({
+				name: z.string().min(1).meta({
+					description: "Product name",
+					placeholder: "Enter name...",
+				}),
+				description: z.string().meta({
+					description: "Full description",
+					fieldType: "textarea",
+				}),
+				image: z.string().optional().meta({
+					description: "Product image",
+					fieldType: "file",
+				}),
+				price: z.number().min(0).meta({
+					placeholder: "0.00",
+				}),
+			});
+
+			// Step 2: Convert to JSON Schema (stored in DB as version 2)
+			const jsonSchema = z.toJSONSchema(ProductSchema);
+			const dbStoredString = JSON.stringify(jsonSchema);
+
+			// Step 3: Client fetches and extracts fieldTypes
+			const fetchedSchema = JSON.parse(dbStoredString) as {
+				properties?: Record<
+					string,
+					{ description?: string; placeholder?: string; fieldType?: string }
+				>;
+			};
+
+			// Verify fieldTypes are preserved
+			expect(fetchedSchema.properties?.description?.fieldType).toBe("textarea");
+			expect(fetchedSchema.properties?.image?.fieldType).toBe("file");
+
+			// Verify other meta properties are preserved
+			expect(fetchedSchema.properties?.name?.description).toBe("Product name");
+			expect(fetchedSchema.properties?.name?.placeholder).toBe("Enter name...");
+			expect(fetchedSchema.properties?.price?.placeholder).toBe("0.00");
+		});
+	});
+
+	describe("Legacy schema migration", () => {
+		/**
+		 * Simulates the migrateToUnifiedSchema function from api/plugin.ts
+		 */
+		function migrateToUnifiedSchema(
+			jsonSchemaStr: string,
+			fieldConfigStr: string | null | undefined,
+		): string {
+			if (!fieldConfigStr) {
+				return jsonSchemaStr;
+			}
+
+			try {
+				const jsonSchema = JSON.parse(jsonSchemaStr);
+				const fieldConfig = JSON.parse(fieldConfigStr);
+
+				if (!jsonSchema.properties || typeof fieldConfig !== "object") {
+					return jsonSchemaStr;
+				}
+
+				// Merge fieldType from fieldConfig into each property
+				for (const [key, config] of Object.entries(fieldConfig)) {
+					if (
+						jsonSchema.properties[key] &&
+						typeof config === "object" &&
+						config !== null &&
+						"fieldType" in config
+					) {
+						jsonSchema.properties[key].fieldType = (
+							config as { fieldType: string }
+						).fieldType;
+					}
+				}
+
+				return JSON.stringify(jsonSchema);
+			} catch {
+				return jsonSchemaStr;
+			}
+		}
+
+		it("merges legacy fieldConfig into JSON Schema", () => {
+			// Legacy format: separate jsonSchema and fieldConfig
+			const legacyJsonSchema = JSON.stringify({
+				type: "object",
+				properties: {
+					name: { type: "string", description: "Product name" },
+					description: { type: "string" },
+					image: { type: "string" },
+				},
+				required: ["name", "description"],
+			});
+
+			const legacyFieldConfig = JSON.stringify({
+				description: { fieldType: "textarea" },
+				image: { fieldType: "file" },
+			});
+
+			// Migrate
+			const migratedStr = migrateToUnifiedSchema(
+				legacyJsonSchema,
+				legacyFieldConfig,
+			);
+			const migrated = JSON.parse(migratedStr);
+
+			// Verify fieldTypes are now embedded
+			expect(migrated.properties.description.fieldType).toBe("textarea");
+			expect(migrated.properties.image.fieldType).toBe("file");
+
+			// Verify other properties are preserved
+			expect(migrated.properties.name.description).toBe("Product name");
+			expect(migrated.required).toEqual(["name", "description"]);
+		});
+
+		it("handles null fieldConfig", () => {
+			const jsonSchema = JSON.stringify({
+				type: "object",
+				properties: {
+					name: { type: "string" },
+				},
+			});
+
+			const result = migrateToUnifiedSchema(jsonSchema, null);
+			expect(result).toBe(jsonSchema);
+		});
+
+		it("handles undefined fieldConfig", () => {
+			const jsonSchema = JSON.stringify({
+				type: "object",
+				properties: {
+					name: { type: "string" },
+				},
+			});
+
+			const result = migrateToUnifiedSchema(jsonSchema, undefined);
+			expect(result).toBe(jsonSchema);
+		});
+
+		it("handles invalid JSON gracefully", () => {
+			const jsonSchema = "invalid json";
+			const fieldConfig = "also invalid";
+
+			const result = migrateToUnifiedSchema(jsonSchema, fieldConfig);
+			expect(result).toBe(jsonSchema); // Returns original on error
+		});
+	});
+
 	describe("AutoForm schema generation and data shape", () => {
 		/**
 		 * Helper function to convert JSON Schema to Zod with coercion for AutoForm

package/src/plugins/cms/api/plugin.ts

@@ -16,12 +16,66 @@ import type {
 import { listContentQuerySchema } from "../schemas";
 import { slugify } from "../utils";
 
+/**
+ * Migrate a legacy JSON Schema (version 1) to unified format (version 2)
+ * by merging fieldConfig values into the JSON Schema properties
+ */
+function migrateToUnifiedSchema(
+	jsonSchemaStr: string,
+	fieldConfigStr: string | null | undefined,
+): string {
+	if (!fieldConfigStr) {
+		return jsonSchemaStr;
+	}
+
+	try {
+		const jsonSchema = JSON.parse(jsonSchemaStr);
+		const fieldConfig = JSON.parse(fieldConfigStr);
+
+		if (!jsonSchema.properties || typeof fieldConfig !== "object") {
+			return jsonSchemaStr;
+		}
+
+		// Merge fieldType from fieldConfig into each property
+		for (const [key, config] of Object.entries(fieldConfig)) {
+			if (
+				jsonSchema.properties[key] &&
+				typeof config === "object" &&
+				config !== null &&
+				"fieldType" in config
+			) {
+				jsonSchema.properties[key].fieldType = (
+					config as { fieldType: string }
+				).fieldType;
+			}
+		}
+
+		return JSON.stringify(jsonSchema);
+	} catch {
+		// If parsing fails, return original
+		return jsonSchemaStr;
+	}
+}
+
 /**
  * Serialize a ContentType for API response (convert dates to strings)
+ * Also applies lazy migration for legacy schemas (version 1 → 2)
  */
 function serializeContentType(ct: ContentType): SerializedContentType {
+	// Check if this is a legacy schema that needs migration
+	const needsMigration = !ct.autoFormVersion || ct.autoFormVersion < 2;
+
+	// Apply lazy migration: merge fieldConfig into jsonSchema on read
+	const migratedJsonSchema = needsMigration
+		? migrateToUnifiedSchema(ct.jsonSchema, ct.fieldConfig)
+		: ct.jsonSchema;
+
 	return {
-		...ct,
+		id: ct.id,
+		name: ct.name,
+		slug: ct.slug,
+		description: ct.description,
+		jsonSchema: migratedJsonSchema,
 		createdAt: ct.createdAt.toISOString(),
 		updatedAt: ct.updatedAt.toISOString(),
 	};
@@ -57,6 +111,11 @@ function serializeContentItemWithType(
  * Sync content types from config to database
  * Creates or updates content types based on the developer's Zod schemas
  *
+ * Always writes version 2 format:
+ * - fieldType is embedded in jsonSchema via .meta()
+ * - fieldConfig is set to null (no longer used)
+ * - autoFormVersion is set to 2
+ *
  * Handles race conditions from multiple instances by catching unique constraint
  * errors and verifying the record exists (another instance created it first).
  */
@@ -65,8 +124,8 @@ async function syncContentTypes(
 	config: CMSBackendConfig,
 ): Promise<void> {
 	for (const ct of config.contentTypes) {
+		// Convert Zod schema to JSON Schema - fieldType is now embedded via .meta()
 		const jsonSchema = JSON.stringify(z.toJSONSchema(ct.schema));
-		const fieldConfig = ct.fieldConfig ? JSON.stringify(ct.fieldConfig) : null;
 
 		const existing = await adapter.findOne<ContentType>({
 			model: "contentType",
@@ -81,7 +140,8 @@ async function syncContentTypes(
 					name: ct.name,
 					description: ct.description ?? null,
 					jsonSchema,
-					fieldConfig,
+					fieldConfig: null, // No longer used in version 2
+					autoFormVersion: 2,
 					updatedAt: new Date(),
 				},
 			});
@@ -94,7 +154,8 @@ async function syncContentTypes(
 						slug: ct.slug,
 						description: ct.description ?? null,
 						jsonSchema,
-						fieldConfig,
+						fieldConfig: null, // No longer used in version 2
+						autoFormVersion: 2,
 						createdAt: new Date(),
 						updatedAt: new Date(),
 					},