@btst/stack 3.0.0-rc.2 → 3.0.0-rc.3

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

@@ -1,205 +1,71 @@
 import { defineBackendPlugin, createEndpoint } from '@btst/stack/plugins/api';
 import { z } from 'zod';
-import { formSchemaToZod, zodToFormSchema } from '../../../../../ui/src/lib/schema-converter.mjs';
+import { zodToFormSchema } from '../../../../../ui/src/lib/schema-converter.mjs';
 import { cmsSchema } from '../db.mjs';
 import { createListContentQuerySchema, DEFAULT_MAX_PAGE_SIZE } from '../schemas.mjs';
-import { slugify } from '../utils.mjs';
-import { serializeContentType, getAllContentItems, serializeContentItemWithType, serializeContentItem, getContentItemById, getContentItemBySlug, getAllContentTypes } from './getters.mjs';
-import { createCMSContentItem } from './mutations.mjs';
-import { syncRelations, extractRelationFields, isNewRelationValue, isExistingRelationValue } from './relations.mjs';
+import { getContentItemById, getAllContentItems, getAllContentTypes } from './getters.mjs';
+import { createCMSOperations, CMSContentTypeParamsSchema, CMSContentItemParamsSchema, CMSCreateContentItemBodySchema, CMSUpdateContentItemBodySchema } from './operations.mjs';
 import { CMS_QUERY_KEYS } from './query-key-defs.mjs';
-import { runHook } from '../../utils.mjs';
 
 async function syncContentTypes(adapter, config) {
-  for (const ct of config.contentTypes) {
-    const jsonSchema = JSON.stringify(zodToFormSchema(ct.schema));
+  for (const definition of config.contentTypes) {
+    const jsonSchema = JSON.stringify(zodToFormSchema(definition.schema));
     const existing = await adapter.findOne({
       model: "contentType",
-      where: [{ field: "slug", value: ct.slug, operator: "eq" }]
+      where: [
+        { field: "slug", value: definition.slug, operator: "eq" }
+      ]
     });
     if (existing) {
       await adapter.update({
         model: "contentType",
         where: [{ field: "id", value: existing.id, operator: "eq" }],
         update: {
-          name: ct.name,
-          description: ct.description ?? null,
+          name: definition.name,
+          description: definition.description ?? null,
           jsonSchema,
           fieldConfig: null,
-          // No longer used in version 2
           autoFormVersion: 2,
           updatedAt: /* @__PURE__ */ new Date()
         }
       });
-    } else {
-      try {
-        await adapter.create({
-          model: "contentType",
-          data: {
-            name: ct.name,
-            slug: ct.slug,
-            description: ct.description ?? null,
-            jsonSchema,
-            fieldConfig: null,
-            // No longer used in version 2
-            autoFormVersion: 2,
-            createdAt: /* @__PURE__ */ new Date(),
-            updatedAt: /* @__PURE__ */ new Date()
-          }
-        });
-      } catch (err) {
-        const nowExists = await adapter.findOne({
-          model: "contentType",
-          where: [{ field: "slug", value: ct.slug, operator: "eq" }]
-        });
-        if (nowExists) {
-          continue;
-        }
-        const message = err instanceof Error ? err.message : "Unknown database error";
-        throw new Error(
-          `Failed to create content type "${ct.slug}": ${message}`
-        );
-      }
-    }
-  }
-}
-function getContentTypeZodSchema(contentType) {
-  const jsonSchema = JSON.parse(contentType.jsonSchema);
-  return formSchemaToZod(jsonSchema);
-}
-async function processRelationsInData(adapter, contentType, data, getContentTypeFn) {
-  const relationFields = extractRelationFields(contentType);
-  const processedData = { ...data };
-  const relationIds = {};
-  for (const [fieldName, relationConfig] of Object.entries(relationFields)) {
-    if (!(fieldName in data)) {
       continue;
     }
-    const fieldValue = data[fieldName];
-    if (!fieldValue) {
-      relationIds[fieldName] = [];
-      continue;
-    }
-    const targetContentType = await getContentTypeFn(relationConfig.targetType);
-    if (!targetContentType) {
-      throw new Error(
-        `Target content type "${relationConfig.targetType}" not found for relation field "${fieldName}"`
-      );
-    }
-    const ids = [];
-    if (relationConfig.type === "belongsTo") {
-      const value = fieldValue;
-      if (isNewRelationValue(value)) {
-        const newItem = await createRelatedItem(
-          adapter,
-          targetContentType,
-          value.data
-        );
-        ids.push(newItem.id);
-        processedData[fieldName] = { id: newItem.id };
-      } else if (isExistingRelationValue(value)) {
-        ids.push(value.id);
-      }
-    } else {
-      const values = Array.isArray(fieldValue) ? fieldValue : [];
-      const processedValues = [];
-      for (const value of values) {
-        if (isNewRelationValue(value)) {
-          const newItem = await createRelatedItem(
-            adapter,
-            targetContentType,
-            value.data
-          );
-          ids.push(newItem.id);
-          processedValues.push({ id: newItem.id });
-        } else if (isExistingRelationValue(value)) {
-          ids.push(value.id);
-          processedValues.push({ id: value.id });
+    try {
+      await adapter.create({
+        model: "contentType",
+        data: {
+          name: definition.name,
+          slug: definition.slug,
+          description: definition.description ?? null,
+          jsonSchema,
+          fieldConfig: null,
+          autoFormVersion: 2,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
         }
-      }
-      processedData[fieldName] = processedValues;
-    }
-    relationIds[fieldName] = ids;
-  }
-  return { processedData, relationIds };
-}
-async function createRelatedItem(adapter, targetContentType, data) {
-  const slug = slugify(
-    data.slug || data.name || data.title || `item-${Date.now()}`
-  );
-  const zodSchema = getContentTypeZodSchema(targetContentType);
-  const validation = zodSchema.safeParse(data);
-  if (!validation.success) {
-    throw new Error(
-      `Validation failed for new ${targetContentType.slug}: ${JSON.stringify(validation.error.issues)}`
-    );
-  }
-  const existing = await adapter.findOne({
-    model: "contentItem",
-    where: [
-      {
-        field: "contentTypeId",
-        value: targetContentType.id,
-        operator: "eq"
-      },
-      { field: "slug", value: slug, operator: "eq" }
-    ]
-  });
-  if (existing) {
-    return existing;
-  }
-  const item = await adapter.create({
-    model: "contentItem",
-    data: {
-      contentTypeId: targetContentType.id,
-      slug,
-      data: JSON.stringify(validation.data),
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    }
-  });
-  return item;
-}
-async function populateRelations(adapter, item) {
-  const relations = {};
-  const contentRelations = await adapter.findMany({
-    model: "contentRelation",
-    where: [{ field: "sourceId", value: item.id, operator: "eq" }]
-  });
-  const relationsByField = {};
-  for (const rel of contentRelations) {
-    if (!relationsByField[rel.fieldName]) {
-      relationsByField[rel.fieldName] = [];
-    }
-    relationsByField[rel.fieldName].push(rel.targetId);
-  }
-  for (const [fieldName, targetIds] of Object.entries(relationsByField)) {
-    if (targetIds.length === 0) {
-      relations[fieldName] = [];
-      continue;
-    }
-    const relatedItems = [];
-    for (const targetId of targetIds) {
-      const relatedItem = await adapter.findOne({
-        model: "contentItem",
-        where: [{ field: "id", value: targetId, operator: "eq" }],
-        join: { contentType: true }
       });
-      if (relatedItem) {
-        relatedItems.push(serializeContentItemWithType(relatedItem));
-      }
+    } catch (error) {
+      const nowExists = await adapter.findOne({
+        model: "contentType",
+        where: [
+          { field: "slug", value: definition.slug, operator: "eq" }
+        ]
+      });
+      if (nowExists) continue;
+      throw new Error(
+        `Failed to create content type "${definition.slug}": ${error instanceof Error ? error.message : "Unknown database error"}`
+      );
     }
-    relations[fieldName] = relatedItems;
   }
-  return relations;
 }
 const cmsBackendPlugin = (config) => {
   let syncPromise = null;
   const ensureSynced = (adapter) => {
     if (!syncPromise) {
-      syncPromise = syncContentTypes(adapter, config).catch((err) => {
+      syncPromise = syncContentTypes(adapter, config).catch((error) => {
         syncPromise = null;
-        throw err;
+        throw error;
       });
     }
     return syncPromise;
@@ -207,670 +73,213 @@ const cmsBackendPlugin = (config) => {
   const getContentTypesWithCounts = async (adapter) => {
     const contentTypes = await getAllContentTypes(adapter);
     return Promise.all(
-      contentTypes.map(async (ct) => {
-        const count = await adapter.count({
+      contentTypes.map(async (contentType) => ({
+        ...contentType,
+        itemCount: await adapter.count({
           model: "contentItem",
           where: [
-            { field: "contentTypeId", value: ct.id, operator: "eq" }
+            {
+              field: "contentTypeId",
+              value: contentType.id,
+              operator: "eq"
+            }
           ]
-        });
-        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(CMS_QUERY_KEYS.typesList(), typesWithCounts);
-          break;
-        }
-        case "contentList": {
-          const typeSlug = params?.typeSlug ?? "";
-          const [contentTypes, contentItems] = await Promise.all([
-            getContentTypesWithCounts(adapter),
-            getAllContentItems(adapter, typeSlug, { limit: 20, offset: 0 })
-          ]);
-          qc.setQueryData(CMS_QUERY_KEYS.typesList(), contentTypes);
-          qc.setQueryData(
-            CMS_QUERY_KEYS.contentList({ typeSlug, limit: 20, offset: 0 }),
-            {
-              pages: [
-                {
-                  items: contentItems.items,
-                  total: contentItems.total,
-                  limit: contentItems.limit ?? 20,
-                  offset: contentItems.offset ?? 0
-                }
-              ],
-              pageParams: [0]
-            }
-          );
-          break;
-        }
-        case "editContent": {
-          const typeSlug = params?.typeSlug ?? "";
-          const id = params?.id ?? "";
-          const [contentTypes, item] = await Promise.all([
-            getContentTypesWithCounts(adapter),
-            id ? getContentItemById(adapter, id) : Promise.resolve(null)
-          ]);
-          qc.setQueryData(CMS_QUERY_KEYS.typesList(), contentTypes);
-          if (id) {
-            qc.setQueryData(CMS_QUERY_KEYS.contentDetail(typeSlug, id), item);
+  const createCMSPrefetchForRoute = (adapter) => async function prefetchForRoute(key, queryClient, params) {
+    await ensureSynced(adapter);
+    switch (key) {
+      case "dashboard":
+      case "newContent":
+        queryClient.setQueryData(
+          CMS_QUERY_KEYS.typesList(),
+          await getContentTypesWithCounts(adapter)
+        );
+        break;
+      case "contentList": {
+        const typeSlug = params?.typeSlug ?? "";
+        const [contentTypes, contentItems] = await Promise.all([
+          getContentTypesWithCounts(adapter),
+          getAllContentItems(adapter, typeSlug, { limit: 20, offset: 0 })
+        ]);
+        queryClient.setQueryData(CMS_QUERY_KEYS.typesList(), contentTypes);
+        queryClient.setQueryData(
+          CMS_QUERY_KEYS.contentList({ typeSlug, limit: 20, offset: 0 }),
+          {
+            pages: [
+              {
+                items: contentItems.items,
+                total: contentItems.total,
+                limit: contentItems.limit ?? 20,
+                offset: contentItems.offset ?? 0
+              }
+            ],
+            pageParams: [0]
           }
-          break;
+        );
+        break;
+      }
+      case "editContent": {
+        const typeSlug = params?.typeSlug ?? "";
+        const id = params?.id ?? "";
+        const [contentTypes, item] = await Promise.all([
+          getContentTypesWithCounts(adapter),
+          id ? getContentItemById(adapter, id) : Promise.resolve(null)
+        ]);
+        queryClient.setQueryData(CMS_QUERY_KEYS.typesList(), contentTypes);
+        if (id) {
+          queryClient.setQueryData(
+            CMS_QUERY_KEYS.contentDetail(typeSlug, id),
+            item
+          );
         }
+        break;
       }
-    };
+    }
   };
   return defineBackendPlugin({
-    name: "cms",
+    id: "cms",
     dbPlugin: cmsSchema,
-    api: (adapter) => ({
-      getAllContentTypes: async () => {
-        await ensureSynced(adapter);
-        return getAllContentTypes(adapter);
-      },
-      getAllContentItems: async (contentTypeSlug, params) => {
-        await ensureSynced(adapter);
-        return getAllContentItems(adapter, contentTypeSlug, params);
-      },
-      getContentItemBySlug: async (contentTypeSlug, slug) => {
-        await ensureSynced(adapter);
-        return getContentItemBySlug(adapter, contentTypeSlug, slug);
-      },
-      getContentItemById: async (id) => {
-        await ensureSynced(adapter);
-        return getContentItemById(adapter, id);
-      },
-      prefetchForRoute: createCMSPrefetchForRoute(adapter),
-      // Mutations
-      createContentItem: async (typeSlug, input, options) => {
-        await ensureSynced(adapter);
-        return createCMSContentItem(adapter, typeSlug, input, options);
-      }
+    operations: (adapter) => createCMSOperations(adapter, {
+      ensureSynced: () => ensureSynced(adapter),
+      getContentTypesWithCounts: () => getContentTypesWithCounts(adapter),
+      ...config.maxPageSize !== void 0 ? { maxPageSize: config.maxPageSize } : {},
+      ...config.hooks ? { hooks: config.hooks } : {}
     }),
-    routes: (adapter) => {
-      const listContentQuerySchema = createListContentQuerySchema(
-        config.maxPageSize
-      );
-      const paginationQuerySchema = z.object({
+    /** Lower-level SSG helper that intentionally bypasses auth and hooks. */
+    raw: (adapter) => ({
+      prefetchForRoute: createCMSPrefetchForRoute(adapter)
+    }),
+    routes: (_adapter, _context, operations) => {
+      const listQuerySchema = createListContentQuerySchema(config.maxPageSize);
+      const paginationSchema = z.object({
         limit: z.coerce.number().min(1).max(config.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE).optional().default(20),
         offset: z.coerce.number().min(0).optional().default(0)
       });
-      const getContentType = async (slug) => {
-        await ensureSynced(adapter);
-        return adapter.findOne({
-          model: "contentType",
-          where: [{ field: "slug", value: slug, operator: "eq" }]
-        });
-      };
-      const createContext = (typeSlug, headers) => ({
-        typeSlug,
-        headers
-      });
       const listContentTypes = createEndpoint(
         "/content-types",
-        { method: "GET" },
-        async (ctx) => {
-          await ensureSynced(adapter);
-          const contentTypes = await adapter.findMany({
-            model: "contentType",
-            sortBy: { field: "name", direction: "asc" }
-          });
-          const typesWithCounts = await Promise.all(
-            contentTypes.map(async (ct) => {
-              const itemCount = await adapter.count({
-                model: "contentItem",
-                where: [
-                  {
-                    field: "contentTypeId",
-                    value: ct.id,
-                    operator: "eq"
-                  }
-                ]
-              });
-              return {
-                ...serializeContentType(ct),
-                itemCount
-              };
-            })
-          );
-          return typesWithCounts;
-        }
+        { method: "GET", requireRequest: true },
+        operations.listContentTypes.route(() => ({}))
       );
       const getContentTypeBySlug = createEndpoint(
         "/content-types/:slug",
         {
           method: "GET",
-          params: z.object({ slug: z.string() })
+          params: CMSContentTypeParamsSchema,
+          requireRequest: true
         },
-        async (ctx) => {
-          const { slug } = ctx.params;
-          const contentType = await getContentType(slug);
-          if (!contentType) {
-            throw ctx.error(404, { message: "Content type not found" });
-          }
-          return serializeContentType(contentType);
-        }
+        operations.getContentTypeBySlug.route((ctx) => ctx.params)
       );
       const listContentItems = createEndpoint(
         "/content/:typeSlug",
         {
           method: "GET",
-          params: z.object({ typeSlug: z.string() }),
-          query: listContentQuerySchema
+          params: z.object({ typeSlug: z.string().min(1) }),
+          query: listQuerySchema,
+          requireRequest: true
         },
-        async (ctx) => {
-          const { typeSlug } = ctx.params;
-          const { slug, search, limit, offset } = ctx.query;
-          const contentType = await getContentType(typeSlug);
-          if (!contentType) {
-            throw ctx.error(404, { message: "Content type not found" });
-          }
-          return getAllContentItems(adapter, typeSlug, {
-            slug,
-            search,
-            limit,
-            offset
-          });
-        }
+        operations.listContentItems.route((ctx) => ({
+          typeSlug: ctx.params.typeSlug,
+          query: ctx.query
+        }))
       );
       const getContentItem = createEndpoint(
         "/content/:typeSlug/:id",
         {
           method: "GET",
-          params: z.object({ typeSlug: z.string(), id: z.string() })
+          params: CMSContentItemParamsSchema,
+          requireRequest: true
         },
-        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);
-        }
+        operations.getContentItem.route((ctx) => ctx.params)
       );
       const createContentItem = createEndpoint(
         "/content/:typeSlug",
         {
           method: "POST",
-          params: z.object({ typeSlug: z.string() }),
-          body: z.object({
-            slug: z.string().min(1),
-            // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
-            data: z.object({}).passthrough()
-          })
+          params: z.object({ typeSlug: z.string().min(1) }),
+          body: CMSCreateContentItemBodySchema,
+          requireRequest: true
         },
-        async (ctx) => {
-          const { typeSlug } = ctx.params;
-          const { slug: rawSlug, data } = ctx.body;
-          const context = createContext(typeSlug, ctx.headers);
-          const slug = 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",
-              issues: validation.error.issues
-            });
-          }
-          const existing = await adapter.findOne({
-            model: "contentItem",
-            where: [
-              {
-                field: "contentTypeId",
-                value: contentType.id,
-                operator: "eq"
-              },
-              { field: "slug", value: slug, operator: "eq" }
-            ]
-          });
-          if (existing) {
-            throw ctx.error(409, {
-              message: "Content item with this slug already exists"
-            });
-          }
-          const processedData = validation.data;
-          if (config.hooks?.onBeforeCreate) {
-            await runHook(
-              () => config.hooks.onBeforeCreate(processedData, context),
-              ctx.error,
-              "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 = serializeContentItem(item);
-          if (config.hooks?.onAfterCreate) {
-            await config.hooks.onAfterCreate(serialized, context);
-          }
-          return {
-            ...serialized,
-            parsedData: processedData
-          };
-        }
+        operations.createContentItem.route((ctx) => ({
+          typeSlug: ctx.params.typeSlug,
+          body: ctx.body
+        }))
       );
       const updateContentItem = createEndpoint(
         "/content/:typeSlug/:id",
         {
           method: "PUT",
-          params: z.object({ typeSlug: z.string(), id: z.string() }),
-          body: z.object({
-            slug: z.string().min(1).optional(),
-            // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
-            data: z.object({}).passthrough().optional()
-          })
+          params: CMSContentItemParamsSchema,
+          body: CMSUpdateContentItemBodySchema,
+          requireRequest: true
         },
-        async (ctx) => {
-          const { typeSlug, id } = ctx.params;
-          const { slug: rawSlug, data } = ctx.body;
-          const context = createContext(typeSlug, ctx.headers);
-          const slug = rawSlug ? slugify(rawSlug) : void 0;
-          if (rawSlug && !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 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({
-              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",
-                issues: validation.error.issues
-              });
-            }
-            validatedData = validation.data;
-          }
-          const processedData = validatedData;
-          if (config.hooks?.onBeforeUpdate && validatedData) {
-            await runHook(
-              () => config.hooks.onBeforeUpdate(id, validatedData, context),
-              ctx.error,
-              "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 = serializeContentItem(updated);
-          if (config.hooks?.onAfterUpdate) {
-            await config.hooks.onAfterUpdate(serialized, context);
-          }
-          return serializeContentItemWithType(updated);
-        }
+        operations.updateContentItem.route((ctx) => ({
+          ...ctx.params,
+          body: ctx.body
+        }))
       );
       const deleteContentItem = createEndpoint(
         "/content/:typeSlug/:id",
         {
           method: "DELETE",
-          params: z.object({ typeSlug: z.string(), id: z.string() })
+          params: CMSContentItemParamsSchema,
+          requireRequest: true
         },
-        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) {
-            await runHook(
-              () => config.hooks.onBeforeDelete(id, context),
-              ctx.error,
-              "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 };
-        }
+        operations.deleteContentItem.route((ctx) => ctx.params)
       );
       const getContentItemPopulated = createEndpoint(
         "/content/:typeSlug/:id/populated",
         {
           method: "GET",
-          params: z.object({ typeSlug: z.string(), id: z.string() })
+          params: CMSContentItemParamsSchema,
+          requireRequest: true
         },
-        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
-          };
-        }
+        operations.getContentItemPopulated.route((ctx) => ctx.params)
       );
       const listContentByRelation = createEndpoint(
         "/content/:typeSlug/by-relation",
         {
           method: "GET",
-          params: z.object({ typeSlug: z.string() }),
-          query: z.object({
-            field: z.string(),
-            targetId: z.string()
-          }).merge(paginationQuerySchema)
+          params: z.object({ typeSlug: z.string().min(1) }),
+          query: z.object({ field: z.string(), targetId: z.string() }).merge(paginationSchema),
+          requireRequest: true
         },
-        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(serializeContentItemWithType),
-            total,
-            limit,
-            offset
-          };
-        }
+        operations.listContentByRelation.route((ctx) => ({
+          typeSlug: ctx.params.typeSlug,
+          query: ctx.query
+        }))
       );
       const getInverseRelations = createEndpoint(
         "/content-types/:slug/inverse-relations",
         {
           method: "GET",
-          params: z.object({ slug: z.string() }),
-          query: z.object({
-            itemId: z.string().optional()
-          })
+          params: CMSContentTypeParamsSchema,
+          query: z.object({ itemId: z.string().optional() }),
+          requireRequest: true
         },
-        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: "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",
-                      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
-                });
-              }
-            }
-          }
-          return { inverseRelations };
-        }
+        operations.getInverseRelations.route((ctx) => ({
+          slug: ctx.params.slug,
+          query: ctx.query
+        }))
       );
       const listInverseRelationItems = createEndpoint(
         "/content-types/:slug/inverse-relations/:sourceType",
         {
           method: "GET",
           params: z.object({
-            slug: z.string(),
-            sourceType: z.string()
+            slug: z.string().min(1),
+            sourceType: z.string().min(1)
           }),
-          query: z.object({
-            itemId: z.string(),
-            fieldName: z.string()
-          }).merge(paginationQuerySchema)
+          query: z.object({ itemId: z.string(), fieldName: z.string() }).merge(paginationSchema),
+          requireRequest: true
         },
-        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: "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",
-              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(serializeContentItemWithType),
-            total,
-            limit,
-            offset
-          };
-        }
+        operations.listInverseRelationItems.route((ctx) => ({
+          slug: ctx.params.slug,
+          sourceType: ctx.params.sourceType,
+          query: ctx.query
+        }))
       );
       return {
         listContentTypes,
@@ -889,4 +298,4 @@ const cmsBackendPlugin = (config) => {
   });
 };
 
-export { cmsBackendPlugin };
+export { CMSContentItemParamsSchema, CMSContentTypeParamsSchema, CMSCreateContentItemBodySchema, CMSUpdateContentItemBodySchema, cmsBackendPlugin };