@btst/stack 2.1.0 → 2.3.0

package/dist/packages/stack/src/plugins/cms/api/plugin.cjs

@@ -6,54 +6,9 @@ const schemaConverter = require('../../../../../ui/src/lib/schema-converter.cjs'
 const db = require('../db.cjs');
 const schemas = require('../schemas.cjs');
 const utils = require('../utils.cjs');
+const getters = require('./getters.cjs');
+const queryKeyDefs = require('./query-key-defs.cjs');
 
-function migrateToUnifiedSchema(jsonSchemaStr, fieldConfigStr) {
-  if (!fieldConfigStr) {
-    return jsonSchemaStr;
-  }
-  try {
-    const jsonSchema = JSON.parse(jsonSchemaStr);
-    const fieldConfig = JSON.parse(fieldConfigStr);
-    if (!jsonSchema.properties || typeof fieldConfig !== "object") {
-      return jsonSchemaStr;
-    }
-    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.fieldType;
-      }
-    }
-    return JSON.stringify(jsonSchema);
-  } catch {
-    return jsonSchemaStr;
-  }
-}
-function serializeContentType(ct) {
-  const needsMigration = !ct.autoFormVersion || ct.autoFormVersion < 2;
-  const migratedJsonSchema = needsMigration ? migrateToUnifiedSchema(ct.jsonSchema, ct.fieldConfig) : ct.jsonSchema;
-  return {
-    id: ct.id,
-    name: ct.name,
-    slug: ct.slug,
-    description: ct.description,
-    jsonSchema: migratedJsonSchema,
-    createdAt: ct.createdAt.toISOString(),
-    updatedAt: ct.updatedAt.toISOString()
-  };
-}
-function serializeContentItem(item) {
-  return {
-    ...item,
-    createdAt: item.createdAt.toISOString(),
-    updatedAt: item.updatedAt.toISOString()
-  };
-}
-function serializeContentItemWithType(item) {
-  return {
-    ...serializeContentItem(item),
-    parsedData: JSON.parse(item.data),
-    contentType: item.contentType ? serializeContentType(item.contentType) : void 0
-  };
-}
 async function syncContentTypes(adapter, config) {
   for (const ct of config.contentTypes) {
     const jsonSchema = JSON.stringify(schemaConverter.zodToFormSchema(ct.schema));
@@ -271,275 +226,246 @@ async function populateRelations(adapter, item) {
         join: { contentType: true }
       });
       if (relatedItem) {
-        relatedItems.push(serializeContentItemWithType(relatedItem));
+        relatedItems.push(getters.serializeContentItemWithType(relatedItem));
       }
     }
     relations[fieldName] = relatedItems;
   }
   return relations;
 }
-const cmsBackendPlugin = (config) => api.defineBackendPlugin({
-  name: "cms",
-  dbPlugin: db.cmsSchema,
-  routes: (adapter) => {
-    let syncPromise = null;
-    const ensureSynced = async () => {
-      if (!syncPromise) {
-        syncPromise = syncContentTypes(adapter, config).catch((err) => {
-          syncPromise = null;
-          throw err;
-        });
-      }
-      await syncPromise;
-    };
-    const getContentType = async (slug) => {
-      await ensureSynced();
-      return adapter.findOne({
-        model: "contentType",
-        where: [{ field: "slug", value: slug, operator: "eq" }]
+const cmsBackendPlugin = (config) => {
+  let syncPromise = null;
+  const ensureSynced = (adapter) => {
+    if (!syncPromise) {
+      syncPromise = syncContentTypes(adapter, config).catch((err) => {
+        syncPromise = null;
+        throw err;
       });
-    };
-    const createContext = (typeSlug, headers) => ({
-      typeSlug,
-      headers
-    });
-    const listContentTypes = api.createEndpoint(
-      "/content-types",
-      { method: "GET" },
-      async (ctx) => {
-        await ensureSynced();
-        const contentTypes = await adapter.findMany({
-          model: "contentType",
-          sortBy: { field: "name", direction: "asc" }
+    }
+    return syncPromise;
+  };
+  const getContentTypesWithCounts = async (adapter) => {
+    const contentTypes = await getters.getAllContentTypes(adapter);
+    return Promise.all(
+      contentTypes.map(async (ct) => {
+        const count = await adapter.count({
+          model: "contentItem",
+          where: [
+            { field: "contentTypeId", value: ct.id, operator: "eq" }
+          ]
         });
-        const typesWithCounts = await Promise.all(
-          contentTypes.map(async (ct) => {
-            const items = await adapter.findMany({
-              model: "contentItem",
-              where: [
+        return { ...ct, itemCount: count };
+      })
+    );
+  };
+  const createCMSPrefetchForRoute = (adapter) => {
+    return async function prefetchForRoute(key, qc, params) {
+      await ensureSynced(adapter);
+      switch (key) {
+        case "dashboard":
+        case "newContent": {
+          const typesWithCounts = await getContentTypesWithCounts(adapter);
+          qc.setQueryData(queryKeyDefs.CMS_QUERY_KEYS.typesList(), typesWithCounts);
+          break;
+        }
+        case "contentList": {
+          const typeSlug = params?.typeSlug ?? "";
+          const [contentTypes, contentItems] = await Promise.all([
+            getContentTypesWithCounts(adapter),
+            getters.getAllContentItems(adapter, typeSlug, { limit: 20, offset: 0 })
+          ]);
+          qc.setQueryData(queryKeyDefs.CMS_QUERY_KEYS.typesList(), contentTypes);
+          qc.setQueryData(
+            queryKeyDefs.CMS_QUERY_KEYS.contentList({ typeSlug, limit: 20, offset: 0 }),
+            {
+              pages: [
                 {
-                  field: "contentTypeId",
-                  value: ct.id,
-                  operator: "eq"
+                  items: contentItems.items,
+                  total: contentItems.total,
+                  limit: contentItems.limit ?? 20,
+                  offset: contentItems.offset ?? 0
                 }
-              ]
-            });
-            return {
-              ...serializeContentType(ct),
-              itemCount: items.length
-            };
-          })
-        );
-        return typesWithCounts;
-      }
-    );
-    const getContentTypeBySlug = api.createEndpoint(
-      "/content-types/:slug",
-      {
-        method: "GET",
-        params: z.z.object({ slug: z.z.string() })
-      },
-      async (ctx) => {
-        const { slug } = ctx.params;
-        const contentType = await getContentType(slug);
-        if (!contentType) {
-          throw ctx.error(404, { message: "Content type not found" });
+              ],
+              pageParams: [0]
+            }
+          );
+          break;
+        }
+        case "editContent": {
+          const typeSlug = params?.typeSlug ?? "";
+          const id = params?.id ?? "";
+          const [contentTypes, item] = await Promise.all([
+            getContentTypesWithCounts(adapter),
+            id ? getters.getContentItemById(adapter, id) : Promise.resolve(null)
+          ]);
+          qc.setQueryData(queryKeyDefs.CMS_QUERY_KEYS.typesList(), contentTypes);
+          if (id) {
+            qc.setQueryData(queryKeyDefs.CMS_QUERY_KEYS.contentDetail(typeSlug, id), item);
+          }
+          break;
         }
-        return serializeContentType(contentType);
       }
-    );
-    const listContentItems = api.createEndpoint(
-      "/content/:typeSlug",
-      {
-        method: "GET",
-        params: z.z.object({ typeSlug: z.z.string() }),
-        query: schemas.listContentQuerySchema
+    };
+  };
+  return api.defineBackendPlugin({
+    name: "cms",
+    dbPlugin: db.cmsSchema,
+    api: (adapter) => ({
+      getAllContentTypes: async () => {
+        await ensureSynced(adapter);
+        return getters.getAllContentTypes(adapter);
       },
-      async (ctx) => {
-        const { typeSlug } = ctx.params;
-        const { slug, limit, offset } = ctx.query;
-        const contentType = await getContentType(typeSlug);
-        if (!contentType) {
-          throw ctx.error(404, { message: "Content type not found" });
-        }
-        const whereConditions = [
-          {
-            field: "contentTypeId",
-            value: contentType.id,
-            operator: "eq"
-          }
-        ];
-        if (slug) {
-          whereConditions.push({
-            field: "slug",
-            value: slug,
-            operator: "eq"
-          });
-        }
-        const allItems = await adapter.findMany({
-          model: "contentItem",
-          where: whereConditions
-        });
-        const total = allItems.length;
-        const items = await adapter.findMany({
-          model: "contentItem",
-          where: whereConditions,
-          limit,
-          offset,
-          sortBy: { field: "createdAt", direction: "desc" },
-          join: { contentType: true }
-        });
-        return {
-          items: items.map(serializeContentItemWithType),
-          total,
-          limit,
-          offset
-        };
-      }
-    );
-    const getContentItem = api.createEndpoint(
-      "/content/:typeSlug/:id",
-      {
-        method: "GET",
-        params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() })
+      getAllContentItems: async (contentTypeSlug, params) => {
+        await ensureSynced(adapter);
+        return getters.getAllContentItems(adapter, contentTypeSlug, params);
       },
-      async (ctx) => {
-        const { typeSlug, id } = ctx.params;
-        const contentType = await getContentType(typeSlug);
-        if (!contentType) {
-          throw ctx.error(404, { message: "Content type not found" });
-        }
-        const item = await adapter.findOne({
-          model: "contentItem",
-          where: [{ field: "id", value: id, operator: "eq" }],
-          join: { contentType: true }
-        });
-        if (!item || item.contentTypeId !== contentType.id) {
-          throw ctx.error(404, { message: "Content item not found" });
-        }
-        return serializeContentItemWithType(item);
-      }
-    );
-    const createContentItem = api.createEndpoint(
-      "/content/:typeSlug",
-      {
-        method: "POST",
-        params: z.z.object({ typeSlug: z.z.string() }),
-        body: z.z.object({
-          slug: z.z.string().min(1),
-          // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
-          data: z.z.object({}).passthrough()
-        })
+      getContentItemBySlug: async (contentTypeSlug, slug) => {
+        await ensureSynced(adapter);
+        return getters.getContentItemBySlug(adapter, contentTypeSlug, slug);
       },
-      async (ctx) => {
-        const { typeSlug } = ctx.params;
-        const { slug: rawSlug, data } = ctx.body;
-        const context = createContext(typeSlug, ctx.headers);
-        const slug = utils.slugify(rawSlug);
-        if (!slug) {
-          throw ctx.error(400, {
-            message: "Invalid slug: must contain at least one alphanumeric character"
-          });
-        }
-        const contentType = await getContentType(typeSlug);
-        if (!contentType) {
-          throw ctx.error(404, { message: "Content type not found" });
-        }
-        const { processedData: dataWithResolvedRelations, relationIds } = await processRelationsInData(
-          adapter,
-          contentType,
-          data,
-          getContentType
-        );
-        const zodSchema = getContentTypeZodSchema(contentType);
-        const validation = zodSchema.safeParse(dataWithResolvedRelations);
-        if (!validation.success) {
-          throw ctx.error(400, {
-            message: "Validation failed",
-            errors: validation.error.issues
-          });
-        }
-        const existing = await adapter.findOne({
-          model: "contentItem",
-          where: [
-            {
-              field: "contentTypeId",
-              value: contentType.id,
-              operator: "eq"
-            },
-            { field: "slug", value: slug, operator: "eq" }
-          ]
+      getContentItemById: async (id) => {
+        await ensureSynced(adapter);
+        return getters.getContentItemById(adapter, id);
+      },
+      prefetchForRoute: createCMSPrefetchForRoute(adapter)
+    }),
+    routes: (adapter) => {
+      const getContentType = async (slug) => {
+        await ensureSynced(adapter);
+        return adapter.findOne({
+          model: "contentType",
+          where: [{ field: "slug", value: slug, operator: "eq" }]
         });
-        if (existing) {
-          throw ctx.error(409, {
-            message: "Content item with this slug already exists"
+      };
+      const createContext = (typeSlug, headers) => ({
+        typeSlug,
+        headers
+      });
+      const listContentTypes = api.createEndpoint(
+        "/content-types",
+        { method: "GET" },
+        async (ctx) => {
+          await ensureSynced(adapter);
+          const contentTypes = await adapter.findMany({
+            model: "contentType",
+            sortBy: { field: "name", direction: "asc" }
           });
-        }
-        const processedData = validation.data;
-        if (config.hooks?.onBeforeCreate) {
-          const result = await config.hooks.onBeforeCreate(
-            processedData,
-            context
+          const typesWithCounts = await Promise.all(
+            contentTypes.map(async (ct) => {
+              const items = await adapter.findMany({
+                model: "contentItem",
+                where: [
+                  {
+                    field: "contentTypeId",
+                    value: ct.id,
+                    operator: "eq"
+                  }
+                ]
+              });
+              return {
+                ...getters.serializeContentType(ct),
+                itemCount: items.length
+              };
+            })
           );
-          if (result === false) {
-            throw ctx.error(403, { message: "Create operation denied" });
+          return typesWithCounts;
+        }
+      );
+      const getContentTypeBySlug = api.createEndpoint(
+        "/content-types/:slug",
+        {
+          method: "GET",
+          params: z.z.object({ slug: z.z.string() })
+        },
+        async (ctx) => {
+          const { slug } = ctx.params;
+          const contentType = await getContentType(slug);
+          if (!contentType) {
+            throw ctx.error(404, { message: "Content type not found" });
           }
+          return getters.serializeContentType(contentType);
         }
-        const item = await adapter.create({
-          model: "contentItem",
-          data: {
-            contentTypeId: contentType.id,
-            slug,
-            data: JSON.stringify(processedData),
-            createdAt: /* @__PURE__ */ new Date(),
-            updatedAt: /* @__PURE__ */ new Date()
+      );
+      const listContentItems = api.createEndpoint(
+        "/content/:typeSlug",
+        {
+          method: "GET",
+          params: z.z.object({ typeSlug: z.z.string() }),
+          query: schemas.listContentQuerySchema
+        },
+        async (ctx) => {
+          const { typeSlug } = ctx.params;
+          const { slug, limit, offset } = ctx.query;
+          const contentType = await getContentType(typeSlug);
+          if (!contentType) {
+            throw ctx.error(404, { message: "Content type not found" });
           }
-        });
-        await syncRelations(adapter, item.id, relationIds);
-        const serialized = serializeContentItem(item);
-        if (config.hooks?.onAfterCreate) {
-          await config.hooks.onAfterCreate(serialized, context);
+          return getters.getAllContentItems(adapter, typeSlug, { slug, limit, offset });
         }
-        return {
-          ...serialized,
-          parsedData: processedData
-        };
-      }
-    );
-    const updateContentItem = api.createEndpoint(
-      "/content/:typeSlug/:id",
-      {
-        method: "PUT",
-        params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() }),
-        body: z.z.object({
-          slug: z.z.string().min(1).optional(),
-          // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
-          data: z.z.object({}).passthrough().optional()
-        })
-      },
-      async (ctx) => {
-        const { typeSlug, id } = ctx.params;
-        const { slug: rawSlug, data } = ctx.body;
-        const context = createContext(typeSlug, ctx.headers);
-        const slug = rawSlug ? utils.slugify(rawSlug) : void 0;
-        if (rawSlug && !slug) {
-          throw ctx.error(400, {
-            message: "Invalid slug: must contain at least one alphanumeric character"
+      );
+      const getContentItem = api.createEndpoint(
+        "/content/:typeSlug/:id",
+        {
+          method: "GET",
+          params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() })
+        },
+        async (ctx) => {
+          const { typeSlug, id } = ctx.params;
+          const contentType = await getContentType(typeSlug);
+          if (!contentType) {
+            throw ctx.error(404, { message: "Content type not found" });
+          }
+          const item = await adapter.findOne({
+            model: "contentItem",
+            where: [{ field: "id", value: id, operator: "eq" }],
+            join: { contentType: true }
           });
+          if (!item || item.contentTypeId !== contentType.id) {
+            throw ctx.error(404, { message: "Content item not found" });
+          }
+          return getters.serializeContentItemWithType(item);
         }
-        const contentType = await getContentType(typeSlug);
-        if (!contentType) {
-          throw ctx.error(404, { message: "Content type not found" });
-        }
-        const existing = await adapter.findOne({
-          model: "contentItem",
-          where: [{ field: "id", value: id, operator: "eq" }]
-        });
-        if (!existing || existing.contentTypeId !== contentType.id) {
-          throw ctx.error(404, { message: "Content item not found" });
-        }
-        if (slug && slug !== existing.slug) {
-          const duplicate = await adapter.findOne({
+      );
+      const createContentItem = api.createEndpoint(
+        "/content/:typeSlug",
+        {
+          method: "POST",
+          params: z.z.object({ typeSlug: z.z.string() }),
+          body: z.z.object({
+            slug: z.z.string().min(1),
+            // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
+            data: z.z.object({}).passthrough()
+          })
+        },
+        async (ctx) => {
+          const { typeSlug } = ctx.params;
+          const { slug: rawSlug, data } = ctx.body;
+          const context = createContext(typeSlug, ctx.headers);
+          const slug = utils.slugify(rawSlug);
+          if (!slug) {
+            throw ctx.error(400, {
+              message: "Invalid slug: must contain at least one alphanumeric character"
+            });
+          }
+          const contentType = await getContentType(typeSlug);
+          if (!contentType) {
+            throw ctx.error(404, { message: "Content type not found" });
+          }
+          const { processedData: dataWithResolvedRelations, relationIds } = await processRelationsInData(
+            adapter,
+            contentType,
+            data,
+            getContentType
+          );
+          const zodSchema = getContentTypeZodSchema(contentType);
+          const validation = zodSchema.safeParse(dataWithResolvedRelations);
+          if (!validation.success) {
+            throw ctx.error(400, {
+              message: "Validation failed",
+              errors: validation.error.issues
+            });
+          }
+          const existing = await adapter.findOne({
             model: "contentItem",
             where: [
               {
@@ -550,367 +476,448 @@ const cmsBackendPlugin = (config) => api.defineBackendPlugin({
               { field: "slug", value: slug, operator: "eq" }
             ]
           });
-          if (duplicate) {
+          if (existing) {
             throw ctx.error(409, {
               message: "Content item with this slug already exists"
             });
           }
-        }
-        let dataWithResolvedRelations;
-        let relationIds;
-        if (data) {
-          const result = await processRelationsInData(
-            adapter,
-            contentType,
-            data,
-            getContentType
-          );
-          dataWithResolvedRelations = result.processedData;
-          relationIds = result.relationIds;
-        }
-        let validatedData = dataWithResolvedRelations;
-        if (dataWithResolvedRelations) {
-          const existingData = existing.data ? JSON.parse(existing.data) : {};
-          const mergedData = {
-            ...existingData,
-            ...dataWithResolvedRelations
+          const processedData = validation.data;
+          if (config.hooks?.onBeforeCreate) {
+            const result = await config.hooks.onBeforeCreate(
+              processedData,
+              context
+            );
+            if (result === false) {
+              throw ctx.error(403, { message: "Create operation denied" });
+            }
+          }
+          const item = await adapter.create({
+            model: "contentItem",
+            data: {
+              contentTypeId: contentType.id,
+              slug,
+              data: JSON.stringify(processedData),
+              createdAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date()
+            }
+          });
+          await syncRelations(adapter, item.id, relationIds);
+          const serialized = getters.serializeContentItem(item);
+          if (config.hooks?.onAfterCreate) {
+            await config.hooks.onAfterCreate(serialized, context);
+          }
+          return {
+            ...serialized,
+            parsedData: processedData
           };
-          const zodSchema = getContentTypeZodSchema(contentType);
-          const validation = zodSchema.safeParse(mergedData);
-          if (!validation.success) {
+        }
+      );
+      const updateContentItem = api.createEndpoint(
+        "/content/:typeSlug/:id",
+        {
+          method: "PUT",
+          params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() }),
+          body: z.z.object({
+            slug: z.z.string().min(1).optional(),
+            // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
+            data: z.z.object({}).passthrough().optional()
+          })
+        },
+        async (ctx) => {
+          const { typeSlug, id } = ctx.params;
+          const { slug: rawSlug, data } = ctx.body;
+          const context = createContext(typeSlug, ctx.headers);
+          const slug = rawSlug ? utils.slugify(rawSlug) : void 0;
+          if (rawSlug && !slug) {
             throw ctx.error(400, {
-              message: "Validation failed",
-              errors: validation.error.issues
+              message: "Invalid slug: must contain at least one alphanumeric character"
             });
           }
-          validatedData = validation.data;
-        }
-        const processedData = validatedData;
-        if (config.hooks?.onBeforeUpdate && validatedData) {
-          const result = await config.hooks.onBeforeUpdate(
-            id,
-            validatedData,
-            context
-          );
-          if (result === false) {
-            throw ctx.error(403, { message: "Update operation denied" });
+          const contentType = await getContentType(typeSlug);
+          if (!contentType) {
+            throw ctx.error(404, { message: "Content type not found" });
           }
-        }
-        if (relationIds) {
-          await syncRelations(adapter, id, relationIds);
-        }
-        const updateData = {
-          updatedAt: /* @__PURE__ */ new Date()
-        };
-        if (slug) updateData.slug = slug;
-        if (processedData) updateData.data = JSON.stringify(processedData);
-        await adapter.update({
-          model: "contentItem",
-          where: [{ field: "id", value: id, operator: "eq" }],
-          update: updateData
-        });
-        const updated = await adapter.findOne({
-          model: "contentItem",
-          where: [{ field: "id", value: id, operator: "eq" }],
-          join: { contentType: true }
-        });
-        if (!updated) {
-          throw ctx.error(500, { message: "Failed to fetch updated item" });
-        }
-        const serialized = serializeContentItem(updated);
-        if (config.hooks?.onAfterUpdate) {
-          await config.hooks.onAfterUpdate(serialized, context);
-        }
-        return serializeContentItemWithType(updated);
-      }
-    );
-    const deleteContentItem = api.createEndpoint(
-      "/content/:typeSlug/:id",
-      {
-        method: "DELETE",
-        params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() })
-      },
-      async (ctx) => {
-        const { typeSlug, id } = ctx.params;
-        const context = createContext(typeSlug, ctx.headers);
-        const contentType = await getContentType(typeSlug);
-        if (!contentType) {
-          throw ctx.error(404, { message: "Content type not found" });
-        }
-        const existing = await adapter.findOne({
-          model: "contentItem",
-          where: [{ field: "id", value: id, operator: "eq" }]
-        });
-        if (!existing || existing.contentTypeId !== contentType.id) {
-          throw ctx.error(404, { message: "Content item not found" });
-        }
-        if (config.hooks?.onBeforeDelete) {
-          const canDelete = await config.hooks.onBeforeDelete(id, context);
-          if (!canDelete) {
-            throw ctx.error(403, { message: "Delete operation denied" });
+          const existing = await adapter.findOne({
+            model: "contentItem",
+            where: [{ field: "id", value: id, operator: "eq" }]
+          });
+          if (!existing || existing.contentTypeId !== contentType.id) {
+            throw ctx.error(404, { message: "Content item not found" });
           }
-        }
-        await adapter.delete({
-          model: "contentItem",
-          where: [{ field: "id", value: id, operator: "eq" }]
-        });
-        if (config.hooks?.onAfterDelete) {
-          await config.hooks.onAfterDelete(id, context);
-        }
-        return { success: true };
-      }
-    );
-    const getContentItemPopulated = api.createEndpoint(
-      "/content/:typeSlug/:id/populated",
-      {
-        method: "GET",
-        params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() })
-      },
-      async (ctx) => {
-        const { typeSlug, id } = ctx.params;
-        const contentType = await getContentType(typeSlug);
-        if (!contentType) {
-          throw ctx.error(404, { message: "Content type not found" });
-        }
-        const item = await adapter.findOne({
-          model: "contentItem",
-          where: [{ field: "id", value: id, operator: "eq" }],
-          join: { contentType: true }
-        });
-        if (!item || item.contentTypeId !== contentType.id) {
-          throw ctx.error(404, { message: "Content item not found" });
-        }
-        const _relations = await populateRelations(adapter, item);
-        return {
-          ...serializeContentItemWithType(item),
-          _relations
-        };
-      }
-    );
-    const listContentByRelation = api.createEndpoint(
-      "/content/:typeSlug/by-relation",
-      {
-        method: "GET",
-        params: z.z.object({ typeSlug: z.z.string() }),
-        query: z.z.object({
-          field: z.z.string(),
-          targetId: z.z.string(),
-          limit: z.z.coerce.number().min(1).max(100).optional().default(20),
-          offset: z.z.coerce.number().min(0).optional().default(0)
-        })
-      },
-      async (ctx) => {
-        const { typeSlug } = ctx.params;
-        const { field, targetId, limit, offset } = ctx.query;
-        const contentType = await getContentType(typeSlug);
-        if (!contentType) {
-          throw ctx.error(404, { message: "Content type not found" });
-        }
-        const contentRelations = await adapter.findMany({
-          model: "contentRelation",
-          where: [
-            { field: "targetId", value: targetId, operator: "eq" },
-            { field: "fieldName", value: field, operator: "eq" }
-          ]
-        });
-        const sourceIds = [
-          ...new Set(contentRelations.map((r) => r.sourceId))
-        ];
-        if (sourceIds.length === 0) {
-          return {
-            items: [],
-            total: 0,
-            limit,
-            offset
+          if (slug && slug !== existing.slug) {
+            const duplicate = await adapter.findOne({
+              model: "contentItem",
+              where: [
+                {
+                  field: "contentTypeId",
+                  value: contentType.id,
+                  operator: "eq"
+                },
+                { field: "slug", value: slug, operator: "eq" }
+              ]
+            });
+            if (duplicate) {
+              throw ctx.error(409, {
+                message: "Content item with this slug already exists"
+              });
+            }
+          }
+          let dataWithResolvedRelations;
+          let relationIds;
+          if (data) {
+            const result = await processRelationsInData(
+              adapter,
+              contentType,
+              data,
+              getContentType
+            );
+            dataWithResolvedRelations = result.processedData;
+            relationIds = result.relationIds;
+          }
+          let validatedData = dataWithResolvedRelations;
+          if (dataWithResolvedRelations) {
+            const existingData = existing.data ? JSON.parse(existing.data) : {};
+            const mergedData = {
+              ...existingData,
+              ...dataWithResolvedRelations
+            };
+            const zodSchema = getContentTypeZodSchema(contentType);
+            const validation = zodSchema.safeParse(mergedData);
+            if (!validation.success) {
+              throw ctx.error(400, {
+                message: "Validation failed",
+                errors: validation.error.issues
+              });
+            }
+            validatedData = validation.data;
+          }
+          const processedData = validatedData;
+          if (config.hooks?.onBeforeUpdate && validatedData) {
+            const result = await config.hooks.onBeforeUpdate(
+              id,
+              validatedData,
+              context
+            );
+            if (result === false) {
+              throw ctx.error(403, { message: "Update operation denied" });
+            }
+          }
+          if (relationIds) {
+            await syncRelations(adapter, id, relationIds);
+          }
+          const updateData = {
+            updatedAt: /* @__PURE__ */ new Date()
           };
+          if (slug) updateData.slug = slug;
+          if (processedData) updateData.data = JSON.stringify(processedData);
+          await adapter.update({
+            model: "contentItem",
+            where: [{ field: "id", value: id, operator: "eq" }],
+            update: updateData
+          });
+          const updated = await adapter.findOne({
+            model: "contentItem",
+            where: [{ field: "id", value: id, operator: "eq" }],
+            join: { contentType: true }
+          });
+          if (!updated) {
+            throw ctx.error(500, { message: "Failed to fetch updated item" });
+          }
+          const serialized = getters.serializeContentItem(updated);
+          if (config.hooks?.onAfterUpdate) {
+            await config.hooks.onAfterUpdate(serialized, context);
+          }
+          return getters.serializeContentItemWithType(updated);
         }
-        const allItems = [];
-        for (const sourceId of sourceIds) {
+      );
+      const deleteContentItem = api.createEndpoint(
+        "/content/:typeSlug/:id",
+        {
+          method: "DELETE",
+          params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() })
+        },
+        async (ctx) => {
+          const { typeSlug, id } = ctx.params;
+          const context = createContext(typeSlug, ctx.headers);
+          const contentType = await getContentType(typeSlug);
+          if (!contentType) {
+            throw ctx.error(404, { message: "Content type not found" });
+          }
+          const existing = await adapter.findOne({
+            model: "contentItem",
+            where: [{ field: "id", value: id, operator: "eq" }]
+          });
+          if (!existing || existing.contentTypeId !== contentType.id) {
+            throw ctx.error(404, { message: "Content item not found" });
+          }
+          if (config.hooks?.onBeforeDelete) {
+            const canDelete = await config.hooks.onBeforeDelete(id, context);
+            if (!canDelete) {
+              throw ctx.error(403, { message: "Delete operation denied" });
+            }
+          }
+          await adapter.delete({
+            model: "contentItem",
+            where: [{ field: "id", value: id, operator: "eq" }]
+          });
+          if (config.hooks?.onAfterDelete) {
+            await config.hooks.onAfterDelete(id, context);
+          }
+          return { success: true };
+        }
+      );
+      const getContentItemPopulated = api.createEndpoint(
+        "/content/:typeSlug/:id/populated",
+        {
+          method: "GET",
+          params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() })
+        },
+        async (ctx) => {
+          const { typeSlug, id } = ctx.params;
+          const contentType = await getContentType(typeSlug);
+          if (!contentType) {
+            throw ctx.error(404, { message: "Content type not found" });
+          }
           const item = await adapter.findOne({
             model: "contentItem",
-            where: [
-              { field: "id", value: sourceId, operator: "eq" },
-              {
-                field: "contentTypeId",
-                value: contentType.id,
-                operator: "eq"
-              }
-            ],
+            where: [{ field: "id", value: id, operator: "eq" }],
             join: { contentType: true }
           });
-          if (item) {
-            allItems.push(item);
+          if (!item || item.contentTypeId !== contentType.id) {
+            throw ctx.error(404, { message: "Content item not found" });
           }
+          const _relations = await populateRelations(adapter, item);
+          return {
+            ...getters.serializeContentItemWithType(item),
+            _relations
+          };
         }
-        allItems.sort(
-          (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
-        );
-        const total = allItems.length;
-        const paginatedItems = allItems.slice(offset, offset + limit);
-        return {
-          items: paginatedItems.map(serializeContentItemWithType),
-          total,
-          limit,
-          offset
-        };
-      }
-    );
-    const getInverseRelations = api.createEndpoint(
-      "/content-types/:slug/inverse-relations",
-      {
-        method: "GET",
-        params: z.z.object({ slug: z.z.string() }),
-        query: z.z.object({
-          itemId: z.z.string().optional()
-        })
-      },
-      async (ctx) => {
-        const { slug } = ctx.params;
-        const { itemId } = ctx.query;
-        await ensureSynced();
-        const targetContentType = await getContentType(slug);
-        if (!targetContentType) {
-          throw ctx.error(404, { message: "Content type not found" });
+      );
+      const listContentByRelation = api.createEndpoint(
+        "/content/:typeSlug/by-relation",
+        {
+          method: "GET",
+          params: z.z.object({ typeSlug: z.z.string() }),
+          query: z.z.object({
+            field: z.z.string(),
+            targetId: z.z.string(),
+            limit: z.z.coerce.number().min(1).max(100).optional().default(20),
+            offset: z.z.coerce.number().min(0).optional().default(0)
+          })
+        },
+        async (ctx) => {
+          const { typeSlug } = ctx.params;
+          const { field, targetId, limit, offset } = ctx.query;
+          const contentType = await getContentType(typeSlug);
+          if (!contentType) {
+            throw ctx.error(404, { message: "Content type not found" });
+          }
+          const contentRelations = await adapter.findMany({
+            model: "contentRelation",
+            where: [
+              { field: "targetId", value: targetId, operator: "eq" },
+              { field: "fieldName", value: field, operator: "eq" }
+            ]
+          });
+          const sourceIds = [
+            ...new Set(contentRelations.map((r) => r.sourceId))
+          ];
+          if (sourceIds.length === 0) {
+            return {
+              items: [],
+              total: 0,
+              limit,
+              offset
+            };
+          }
+          const allItems = [];
+          for (const sourceId of sourceIds) {
+            const item = await adapter.findOne({
+              model: "contentItem",
+              where: [
+                { field: "id", value: sourceId, operator: "eq" },
+                {
+                  field: "contentTypeId",
+                  value: contentType.id,
+                  operator: "eq"
+                }
+              ],
+              join: { contentType: true }
+            });
+            if (item) {
+              allItems.push(item);
+            }
+          }
+          allItems.sort(
+            (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+          );
+          const total = allItems.length;
+          const paginatedItems = allItems.slice(offset, offset + limit);
+          return {
+            items: paginatedItems.map(getters.serializeContentItemWithType),
+            total,
+            limit,
+            offset
+          };
         }
-        const allContentTypes = await adapter.findMany({
-          model: "contentType"
-        });
-        const inverseRelations = [];
-        for (const contentType of allContentTypes) {
-          const relationFields = extractRelationFields(contentType);
-          for (const [fieldName, relationConfig] of Object.entries(
-            relationFields
-          )) {
-            if (relationConfig.type === "belongsTo" && relationConfig.targetType === slug) {
-              let count = 0;
-              if (itemId) {
-                const relations = await adapter.findMany({
-                  model: "contentRelation",
-                  where: [
-                    {
-                      field: "targetId",
-                      value: itemId,
-                      operator: "eq"
-                    },
-                    {
-                      field: "fieldName",
-                      value: fieldName,
-                      operator: "eq"
-                    }
-                  ]
-                });
-                const itemIds = relations.map((r) => r.sourceId);
-                for (const sourceId of itemIds) {
-                  const item = await adapter.findOne({
-                    model: "contentItem",
+      );
+      const getInverseRelations = api.createEndpoint(
+        "/content-types/:slug/inverse-relations",
+        {
+          method: "GET",
+          params: z.z.object({ slug: z.z.string() }),
+          query: z.z.object({
+            itemId: z.z.string().optional()
+          })
+        },
+        async (ctx) => {
+          const { slug } = ctx.params;
+          const { itemId } = ctx.query;
+          await ensureSynced(adapter);
+          const targetContentType = await getContentType(slug);
+          if (!targetContentType) {
+            throw ctx.error(404, { message: "Content type not found" });
+          }
+          const allContentTypes = await adapter.findMany({
+            model: "contentType"
+          });
+          const inverseRelations = [];
+          for (const contentType of allContentTypes) {
+            const relationFields = extractRelationFields(contentType);
+            for (const [fieldName, relationConfig] of Object.entries(
+              relationFields
+            )) {
+              if (relationConfig.type === "belongsTo" && relationConfig.targetType === slug) {
+                let count = 0;
+                if (itemId) {
+                  const relations = await adapter.findMany({
+                    model: "contentRelation",
                     where: [
                       {
-                        field: "id",
-                        value: sourceId,
+                        field: "targetId",
+                        value: itemId,
                         operator: "eq"
                       },
                       {
-                        field: "contentTypeId",
-                        value: contentType.id,
+                        field: "fieldName",
+                        value: fieldName,
                         operator: "eq"
                       }
                     ]
                   });
-                  if (item) count++;
+                  const itemIds = relations.map((r) => r.sourceId);
+                  for (const sourceId of itemIds) {
+                    const item = await adapter.findOne({
+                      model: "contentItem",
+                      where: [
+                        {
+                          field: "id",
+                          value: sourceId,
+                          operator: "eq"
+                        },
+                        {
+                          field: "contentTypeId",
+                          value: contentType.id,
+                          operator: "eq"
+                        }
+                      ]
+                    });
+                    if (item) count++;
+                  }
                 }
+                inverseRelations.push({
+                  sourceType: contentType.slug,
+                  sourceTypeName: contentType.name,
+                  fieldName,
+                  count
+                });
               }
-              inverseRelations.push({
-                sourceType: contentType.slug,
-                sourceTypeName: contentType.name,
-                fieldName,
-                count
-              });
             }
           }
+          return { inverseRelations };
         }
-        return { inverseRelations };
-      }
-    );
-    const listInverseRelationItems = api.createEndpoint(
-      "/content-types/:slug/inverse-relations/:sourceType",
-      {
-        method: "GET",
-        params: z.z.object({
-          slug: z.z.string(),
-          sourceType: z.z.string()
-        }),
-        query: z.z.object({
-          itemId: z.z.string(),
-          fieldName: z.z.string(),
-          limit: z.z.coerce.number().min(1).max(100).optional().default(20),
-          offset: z.z.coerce.number().min(0).optional().default(0)
-        })
-      },
-      async (ctx) => {
-        const { slug, sourceType } = ctx.params;
-        const { itemId, fieldName, limit, offset } = ctx.query;
-        await ensureSynced();
-        const targetContentType = await getContentType(slug);
-        if (!targetContentType) {
-          throw ctx.error(404, { message: "Target content type not found" });
-        }
-        const sourceContentType = await getContentType(sourceType);
-        if (!sourceContentType) {
-          throw ctx.error(404, { message: "Source content type not found" });
-        }
-        const relations = await adapter.findMany({
-          model: "contentRelation",
-          where: [
-            { field: "targetId", value: itemId, operator: "eq" },
-            { field: "fieldName", value: fieldName, operator: "eq" }
-          ]
-        });
-        const sourceIds = [...new Set(relations.map((r) => r.sourceId))];
-        const allItems = [];
-        for (const sourceId of sourceIds) {
-          const item = await adapter.findOne({
-            model: "contentItem",
+      );
+      const listInverseRelationItems = api.createEndpoint(
+        "/content-types/:slug/inverse-relations/:sourceType",
+        {
+          method: "GET",
+          params: z.z.object({
+            slug: z.z.string(),
+            sourceType: z.z.string()
+          }),
+          query: z.z.object({
+            itemId: z.z.string(),
+            fieldName: z.z.string(),
+            limit: z.z.coerce.number().min(1).max(100).optional().default(20),
+            offset: z.z.coerce.number().min(0).optional().default(0)
+          })
+        },
+        async (ctx) => {
+          const { slug, sourceType } = ctx.params;
+          const { itemId, fieldName, limit, offset } = ctx.query;
+          await ensureSynced(adapter);
+          const targetContentType = await getContentType(slug);
+          if (!targetContentType) {
+            throw ctx.error(404, { message: "Target content type not found" });
+          }
+          const sourceContentType = await getContentType(sourceType);
+          if (!sourceContentType) {
+            throw ctx.error(404, { message: "Source content type not found" });
+          }
+          const relations = await adapter.findMany({
+            model: "contentRelation",
             where: [
-              { field: "id", value: sourceId, operator: "eq" },
-              {
-                field: "contentTypeId",
-                value: sourceContentType.id,
-                operator: "eq"
-              }
-            ],
-            join: { contentType: true }
+              { field: "targetId", value: itemId, operator: "eq" },
+              { field: "fieldName", value: fieldName, operator: "eq" }
+            ]
           });
-          if (item) {
-            allItems.push(item);
+          const sourceIds = [...new Set(relations.map((r) => r.sourceId))];
+          const allItems = [];
+          for (const sourceId of sourceIds) {
+            const item = await adapter.findOne({
+              model: "contentItem",
+              where: [
+                { field: "id", value: sourceId, operator: "eq" },
+                {
+                  field: "contentTypeId",
+                  value: sourceContentType.id,
+                  operator: "eq"
+                }
+              ],
+              join: { contentType: true }
+            });
+            if (item) {
+              allItems.push(item);
+            }
           }
+          allItems.sort(
+            (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+          );
+          const total = allItems.length;
+          const paginatedItems = allItems.slice(offset, offset + limit);
+          return {
+            items: paginatedItems.map(getters.serializeContentItemWithType),
+            total,
+            limit,
+            offset
+          };
         }
-        allItems.sort(
-          (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
-        );
-        const total = allItems.length;
-        const paginatedItems = allItems.slice(offset, offset + limit);
-        return {
-          items: paginatedItems.map(serializeContentItemWithType),
-          total,
-          limit,
-          offset
-        };
-      }
-    );
-    return {
-      listContentTypes,
-      getContentTypeBySlug,
-      listContentItems,
-      getContentItem,
-      createContentItem,
-      updateContentItem,
-      deleteContentItem,
-      getContentItemPopulated,
-      listContentByRelation,
-      getInverseRelations,
-      listInverseRelationItems
-    };
-  }
-});
+      );
+      return {
+        listContentTypes,
+        getContentTypeBySlug,
+        listContentItems,
+        getContentItem,
+        createContentItem,
+        updateContentItem,
+        deleteContentItem,
+        getContentItemPopulated,
+        listContentByRelation,
+        getInverseRelations,
+        listInverseRelationItems
+      };
+    }
+  });
+};
 
 exports.cmsBackendPlugin = cmsBackendPlugin;