@btst/stack 1.8.0 → 1.9.1

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

@@ -109,6 +109,173 @@ function getContentTypeZodSchema(contentType) {
   const jsonSchema = JSON.parse(contentType.jsonSchema);
   return formSchemaToZod(jsonSchema);
 }
+function extractRelationFields(contentType) {
+  const jsonSchema = JSON.parse(
+    contentType.jsonSchema
+  );
+  const properties = jsonSchema.properties || {};
+  const relationFields = {};
+  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+    if (fieldSchema.fieldType === "relation" && fieldSchema.relation) {
+      relationFields[fieldName] = fieldSchema.relation;
+    }
+  }
+  return relationFields;
+}
+function isNewRelationValue(value) {
+  return typeof value === "object" && value !== null && "_new" in value && value._new === true && "data" in value;
+}
+function isExistingRelationValue(value) {
+  return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string";
+}
+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 });
+        }
+      }
+      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 syncRelations(adapter, sourceId, relationIds) {
+  for (const [fieldName, targetIds] of Object.entries(relationIds)) {
+    await adapter.delete({
+      model: "contentRelation",
+      where: [
+        { field: "sourceId", value: sourceId, operator: "eq" },
+        { field: "fieldName", value: fieldName, operator: "eq" }
+      ]
+    });
+    for (const targetId of targetIds) {
+      await adapter.create({
+        model: "contentRelation",
+        data: {
+          sourceId,
+          targetId,
+          fieldName,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      });
+    }
+  }
+}
+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));
+      }
+    }
+    relations[fieldName] = relatedItems;
+  }
+  return relations;
+}
 const cmsBackendPlugin = (config) => defineBackendPlugin({
   name: "cms",
   dbPlugin: cmsSchema,
@@ -276,8 +443,14 @@ const cmsBackendPlugin = (config) => defineBackendPlugin({
         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(data);
+        const validation = zodSchema.safeParse(dataWithResolvedRelations);
         if (!validation.success) {
           throw ctx.error(400, {
             message: "Validation failed",
@@ -300,36 +473,34 @@ const cmsBackendPlugin = (config) => defineBackendPlugin({
             message: "Content item with this slug already exists"
           });
         }
-        let finalData = validation.data;
+        const processedData = validation.data;
         if (config.hooks?.onBeforeCreate) {
           const result = await config.hooks.onBeforeCreate(
-            validation.data,
+            processedData,
             context
           );
           if (result === false) {
             throw ctx.error(403, { message: "Create operation denied" });
           }
-          if (result && typeof result === "object") {
-            finalData = result;
-          }
         }
         const item = await adapter.create({
           model: "contentItem",
           data: {
             contentTypeId: contentType.id,
             slug,
-            data: JSON.stringify(finalData),
+            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: finalData
+          parsedData: processedData
         };
       }
     );
@@ -383,10 +554,27 @@ const cmsBackendPlugin = (config) => defineBackendPlugin({
             });
           }
         }
-        let validatedData = data;
+        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(data);
+          const validation = zodSchema.safeParse(mergedData);
           if (!validation.success) {
             throw ctx.error(400, {
               message: "Validation failed",
@@ -395,7 +583,7 @@ const cmsBackendPlugin = (config) => defineBackendPlugin({
           }
           validatedData = validation.data;
         }
-        let finalData = validatedData;
+        const processedData = validatedData;
         if (config.hooks?.onBeforeUpdate && validatedData) {
           const result = await config.hooks.onBeforeUpdate(
             id,
@@ -405,15 +593,15 @@ const cmsBackendPlugin = (config) => defineBackendPlugin({
           if (result === false) {
             throw ctx.error(403, { message: "Update operation denied" });
           }
-          if (result && typeof result === "object") {
-            finalData = result;
-          }
+        }
+        if (relationIds) {
+          await syncRelations(adapter, id, relationIds);
         }
         const updateData = {
           updatedAt: /* @__PURE__ */ new Date()
         };
         if (slug) updateData.slug = slug;
-        if (finalData) updateData.data = JSON.stringify(finalData);
+        if (processedData) updateData.data = JSON.stringify(processedData);
         await adapter.update({
           model: "contentItem",
           where: [{ field: "id", value: id, operator: "eq" }],
@@ -470,6 +658,243 @@ const cmsBackendPlugin = (config) => defineBackendPlugin({
         return { success: true };
       }
     );
+    const getContentItemPopulated = createEndpoint(
+      "/content/:typeSlug/:id/populated",
+      {
+        method: "GET",
+        params: z.object({ typeSlug: z.string(), id: 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 = createEndpoint(
+      "/content/:typeSlug/by-relation",
+      {
+        method: "GET",
+        params: z.object({ typeSlug: z.string() }),
+        query: z.object({
+          field: z.string(),
+          targetId: z.string(),
+          limit: z.coerce.number().min(1).max(100).optional().default(20),
+          offset: 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(serializeContentItemWithType),
+          total,
+          limit,
+          offset
+        };
+      }
+    );
+    const getInverseRelations = createEndpoint(
+      "/content-types/:slug/inverse-relations",
+      {
+        method: "GET",
+        params: z.object({ slug: z.string() }),
+        query: z.object({
+          itemId: 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 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 };
+      }
+    );
+    const listInverseRelationItems = createEndpoint(
+      "/content-types/:slug/inverse-relations/:sourceType",
+      {
+        method: "GET",
+        params: z.object({
+          slug: z.string(),
+          sourceType: z.string()
+        }),
+        query: z.object({
+          itemId: z.string(),
+          fieldName: z.string(),
+          limit: z.coerce.number().min(1).max(100).optional().default(20),
+          offset: 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",
+            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
+        };
+      }
+    );
     return {
       listContentTypes,
       getContentTypeBySlug,
@@ -477,7 +902,11 @@ const cmsBackendPlugin = (config) => defineBackendPlugin({
       getContentItem,
       createContentItem,
       updateContentItem,
-      deleteContentItem
+      deleteContentItem,
+      getContentItemPopulated,
+      listContentByRelation,
+      getInverseRelations,
+      listInverseRelationItems
     };
   }
 });

package/dist/packages/better-stack/src/plugins/cms/client/components/forms/content-form.cjs

@@ -4,20 +4,20 @@
 const jsxRuntime = require('react/jsx-runtime');
 const React = require('react');
 const z = require('zod');
-const sonner = require('sonner');
 const steppedAutoForm = require('../../../../../../../ui/src/components/auto-form/stepped-auto-form.cjs');
-const utils = require('../../../../../../../ui/src/components/auto-form/utils.cjs');
+const helpers = require('../../../../../../../ui/src/components/auto-form/helpers.cjs');
 const schemaConverter = require('../../../../../../../ui/src/lib/schema-converter.cjs');
 const input = require('../../../../../../../ui/src/components/input.cjs');
 const label = require('../../../../../../../ui/src/components/label.cjs');
 const badge = require('../../../../../../../ui/src/components/badge.cjs');
 const context = require('@btst/stack/context');
-const utils$1 = require('../../../utils.cjs');
+const utils = require('../../../utils.cjs');
 const index = require('../../localization/index.cjs');
 const fileUpload = require('./file-upload.cjs');
+const relationField = require('./relation-field.cjs');
 
 function buildFieldConfigFromJsonSchema(jsonSchema, uploadImage, fieldComponents) {
-  const baseConfig = utils.buildFieldConfigFromJsonSchema(jsonSchema, fieldComponents);
+  const baseConfig = helpers.buildFieldConfigFromJsonSchema(jsonSchema, fieldComponents);
   const properties = jsonSchema.properties;
   if (!properties) return baseConfig;
   for (const [key, prop] of Object.entries(properties)) {
@@ -38,6 +38,13 @@ function buildFieldConfigFromJsonSchema(jsonSchema, uploadImage, fieldComponents
         };
       }
     }
+    if (prop.fieldType === "relation" && prop.relation && !fieldComponents?.["relation"]) {
+      const relationConfig = prop.relation;
+      baseConfig[key] = {
+        ...baseConfig[key],
+        fieldType: (props) => /* @__PURE__ */ jsxRuntime.jsx(relationField.RelationField, { ...props, relation: relationConfig })
+      };
+    }
   }
   return baseConfig;
 }
@@ -75,9 +82,17 @@ function ContentForm({
   const [slugManuallyEdited, setSlugManuallyEdited] = React.useState(isEditing);
   const [isSubmitting, setIsSubmitting] = React.useState(false);
   const [formData, setFormData] = React.useState(initialData);
+  const [slugError, setSlugError] = React.useState(null);
+  const [submitError, setSubmitError] = React.useState(null);
+  const hasSyncedPrefillRef = React.useRef(false);
   React.useEffect(() => {
-    if (isEditing && Object.keys(initialData).length > 0) {
+    const hasData = Object.keys(initialData).length > 0;
+    const shouldSync = hasData && (isEditing || !hasSyncedPrefillRef.current);
+    if (shouldSync) {
       setFormData(initialData);
+      if (!isEditing) {
+        hasSyncedPrefillRef.current = true;
+      }
     }
   }, [initialData, isEditing]);
   React.useEffect(() => {
@@ -112,24 +127,23 @@ function ContentForm({
     if (!isEditing && !slugManuallyEdited && slugSourceField) {
       const sourceValue = values[slugSourceField];
       if (typeof sourceValue === "string" && sourceValue.trim()) {
-        setSlug(utils$1.slugify(sourceValue));
+        setSlug(utils.slugify(sourceValue));
       }
     }
   };
   const handleSubmit = async (data) => {
+    setSlugError(null);
+    setSubmitError(null);
     if (!slug.trim()) {
-      sonner.toast.error("Slug is required");
+      setSlugError("Slug is required");
       return;
     }
     setIsSubmitting(true);
     try {
       await onSubmit({ slug, data });
-      sonner.toast.success(
-        isEditing ? localization.CMS_TOAST_UPDATE_SUCCESS : localization.CMS_TOAST_CREATE_SUCCESS
-      );
     } catch (error) {
       const message = error instanceof Error ? error.message : localization.CMS_TOAST_ERROR;
-      sonner.toast.error(message);
+      setSubmitError(message);
     } finally {
       setIsSubmitting(false);
     }
@@ -147,6 +161,7 @@ function ContentForm({
           value: slug,
           onChange: (e) => {
             setSlug(e.target.value);
+            setSlugError(null);
             if (!isEditing) {
               setSlugManuallyEdited(true);
             }
@@ -155,8 +170,10 @@ function ContentForm({
           placeholder: slugSourceField ? `Auto-generated from ${slugSourceField}` : "Enter slug..."
         }
       ),
+      slugError && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-destructive", children: slugError }),
       /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", children: localization.CMS_LABEL_SLUG_DESCRIPTION })
     ] }),
+    submitError && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-md border border-destructive/50 bg-destructive/10 p-3", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-destructive", children: submitError }) }),
     /* @__PURE__ */ jsxRuntime.jsx(
       steppedAutoForm.default,
       {